Displaying graphical objects

ABSTRACT

Aspects of the present invention relate to a method of controlling the appearance of a graphical object in a graphical user interface. In an embodiment of an aspect of the invention, an object, such as a widget, in a graphical user interface comprises an instance of a widget class in which arr defined properties and/or methods which control operation of the object; and an associated instance of a look object class in which are defined properties and/or methods which control the look of the object.

The present invention relates to graphical user interfaces. Aspects ofthe present invention relate to a method of controlling the appearanceof a graphical object in a graphical user interface. Aspects of theinvention relate to a receiver/decoder, a television system, a computerprogram product, a computer readable medium and a signal. Aspects of theinvention have a particular, but not exclusive, application in providinga graphical user interface for appliances such as receiver/decoders fordigital television signals. However, aspects of the invention also haveapplication to general purpose computers and other appliances.

Most graphical user interfaces (GUIs) include a similar set of basiccomponents that can be manipulated by a user. These include such objectsas push-buttons, sliders, list boxes, and so forth. Such components arereferred to generically as “widgets”. Although the basic function ofwidgets is common amongst many GUIs, the appearance of the widgetsdiffers from one GUI to another.

Some graphical operating systems, the X window system for example,impose few constraints upon the appearance of widgets that can bedisplayed in the GUI. This allows programmers to develop applicationsusing a number of different widget sets, each of which has its owndistinctive appearance. Moreover, a large number of window managers rununder X which influence the overall appearance of windows created byapplications. Normally, it is possible to exercise some control over theappearance of an application as displayed on the GUI both duringdevelopment of the application and to some extent at run time. However,the appearance is, in both cases, determined by hard coded parts of thewidget set or the window manager. It is not possible for a user tochange significantly the look of an application without re-coding thewidget set, the window manager, or both. Either of these optionsrequires a large amount of re-coding work and a large amount of new codeto be installed on a host system.

One proposal to reduce the amount of re-coding work that must be done inorder to update a look is to build elements (for example, corners,borders, and so forth) of a window in a GUI display from pixel mapsstored in memory of a host system. This may be provided as anindependent aspect of the invention. However, the pixel maps can occupya significant amount of memory when in use, and represent a large amountof data to be transferred when the look is to be updated. This can be asignificant disadvantage if the GUI must operate with limited resourcesand must be updated over a link of limited bandwidth. One example ofsuch a situation arises when an application is executed on areceiver/decoder for digital television signals. Such a decoder has alimited amount of memory as compared with a general purpose computer,and the software (including the look of the GUI) is updated bydownloading data from a channel which forms part of the receivedtelevision signal.

An aim of this invention is to provide an application developer with theability to control the appearance of an application in a consistent andreadily controllable manner, with a minimum of re-coding beingnecessary, and with a minimum of data required to be transferred to anexecution environment.

In a first aspect of the present invention there is provided a method ofcontrolling the appearance of a graphical object in a graphical userinterface, comprising

-   -   defining a look object; and    -   associating the look object with the graphical object.

By explicitly defining a look object, rather than embedding code whichcontrols appearance in an application, the invention may allow greaterflexibility than hitherto in the way in which the appearance of agraphical object is controlled.

Preferably the look object includes code or parameters determining howthe graphical object is displayed, such code or parameters preferablybeing stored in memory. For example, the look object may be defined byobject-oriented program code.

The look object may be defined by instantiating a look object class. Alook object which is defined in this way may contain a pointer toanother look object class (other than that from which it is derived).This can allow the look object to access attributes and/or methods ofthat other look class. In this way, a look object can take itscharacteristics from two or more other looks, which can allow a look tobe created which is the union of two different looks, or allow extracharacteristics to be added to the look.

In order to associate the graphical object with the look object, thegraphical object may include an attribute identifying the look objectassociated with the graphical object.

Preferably, the look object defines actual colours which are assigned tospecific named colours. For example, the look object may define theactual colours which are assigned to at least one of black, white andone or several shades of grey. In this way, the look can define acertain colour scheme, for example, by giving a certain hue to graphicalobjects associated with that look. The look object may also define acolour map which sets the actual colour values which are to be used whendisplaying any particular colour.

In order to change the appearance of the graphical object, either thelook object may be re-defined or modified (for example by changing thecode or parameters at compile time, or the parameters at run time), or adifferent look object may be associated with the graphical object. Themethod may therefore further comprise modifying the appearance of thegraphical object by re-defining or modifying the look object or byassociating a different look object with the graphical object.

If a look object is re-defined or modified, then it may be necessary toupdate the appearance of graphical objects which are associated withthat look object. In order to achieve this, the look object may includean update counter whose value is updated when the look object isre-defined or modified.

Preferably, graphical objects store the value of the update counter ofthe look object which they have affected. Each time a graphical objectis to be redisplayed, the value stored by the graphical object iscompared with the value of the update counter of the look object. If thetwo are different, the graphical object takes into account themodifications in the look object, and stores the new value of the updatecounter.

The look object may include a validation mask which indicates methodsthat can be called by the look object, so that methods which are notimplemented by the look object are not called. The graphical object canaccess the validation mask of the look object to optimise the drawing ofthe graphical object. In this way, calls to methods which are notimplemented can be avoided, which can speed up the drawing of thegraphical object.

In some circumstances, for example when a look object is first created,the look object may be associated with a single graphical object.However, in preferred embodiments, the look object is associated with aplurality of graphical objects. By associating the look object with aplurality of graphical objects, a uniform appearance for those objectsmay be achieved, and the amount of data required for defining the lookobject may be reduced, in comparison to the case where each graphicalobject has its appearance defined independently.

Thus, the method may be a method of controlling the appearance of aplurality of graphical objects in a graphical user interface, and maycomprise associating the look object with the plurality of graphicalobjects.

In certain situations, such as where no graphical objects are associatedwith a look object, it may be desirable to delete the look object, forexample to enable the memory space used by the look object to bere-allocated. This may be particularly important in devices such asreceiver/decoders where memory may be limited. For this purpose (amongstothers) the look object may include a counter which indicates the numberof graphical objects which are associated with that look object.Preferably, each time a graphical object is associated with the lookobject, the counter is incremented, and each time a graphical object isdisassociated with the look object, the counter is decremented. If thecounter is at zero, then it may be assumed that the look object can besafely deleted.

In another method aspect of the invention, there is provided a method ofdefining a graphical object in a graphical user interface, comprisingproviding a look object which controls the appearance of the graphicalobject (for example, by defining properties and/or methods which controlthe appearance of the graphical object), and providing a widget objectwhich controls operation of the graphical object (for example, bydefining properties and/or methods which control the operation of thegraphical object). Any of the features mentioned above may be providedin combination with this aspect.

Any of the methods described above preferably further comprisedisplaying the graphical object, for example on a screen such as acomputer screen or a television screen.

Any of the methods described above may be carried out by areceiver/decoder, such as a digital or analogue televisionreceiver/decoder.

The term “receiver/decoder” used herein may connote a receiver forreceiving either encoded or non-encoded signals, for example, televisionand/or radio signals, which may be broadcast or transmitted by someother means. The term may also connote a decoder for decoding receivedsignals. Embodiments of such receiver/decoders may include a decoderintegral with the receiver for decoding the received signals, forexample, in a “set-top box”, such a decoder functioning in combinationwith a physically separate receiver, or such a decoder includingadditional functions, such as a web browser, a video recorder, or atelevision. In an apparatus aspect of the invention there is providedapparatus for controlling the appearance of a graphical object in agraphical user interface, comprising:

-   -   means for defining a look object, for example by creating or        modifying code or parameters in memory determining how a        graphical object will be displayed; and    -   means for associating the look object with the graphical object,        for example by setting an attribute of the graphical object to        identify the look object.

Preferably the apparatus includes a suitably programmed processor fordefining the look object and for associating the look object with thegraphical object, and memory for storing the look object and thegraphical object. The look object may be defined by object-orientedprogram code. The look object may be defined by instantiating a lookobject class. The look object may contain a pointer to another lookobject class.

The apparatus may be adapted to modify the appearance of the graphicalobject, by re-defining or modifying the look object, or by associating adifferent look object with the graphical object. The look object mayinclude an update counter (such as a location in memory) whose value isupdated when the look object is re-defined or modified.

The look object may include a validation mask (for example, stored inmemory) which indicates methods that can be called by the look object.

The apparatus may be apparatus for controlling the appearance of aplurality of graphical objects in a graphical user interface, and may beadapted to associate the look object with a plurality of graphicalobjects. The look object may include a counter (such as a location inmemory) which indicates the number of graphical objects which areassociated with that look object.

The apparatus may further comprise means, such as a screen (for examplea computer screen or a television screen) for displaying the graphicalobject.

In one embodiment, the apparatus is a receiver/decoder, such as adigital or analogue television receiver/decoder.

In a further aspect, the invention provides an object in a graphicaluser interface, comprising an instance of a widget class which controlsoperation of the object, and an instance of a look object class whichcontrols the appearance of the object.

The invention also provides a widget set for creating objects asdescribed above, the widget set comprising a plurality of widget classesand one or more look object classes. Most typically, the widget setcomprises a plurality of look object classes including a base class anda class derived from the base class.

In order to amend the appearance of the object, the look object classcan be changed. This does not change the function of the object sincefunction is controlled by the widget class. Moreover, it is possible forone instance of the look object class to be used by many instances ofthe widget class, thereby minimising the amount of memory used.

The look object class can be contained in a library linked into anapplication at run time. A user can therefore select a preferred lookfor the object by selecting which one of a range of libraries should belinked. Because the look object class is changed independently of theother items, re-coding is simplified to the minimum necessary toimplement the new look.

Alternatively, the look object class can be contained in a librarylinked into an application at compile time. This allows an applicationdeveloper to have full control of the appearance of the object.

The look object class may export drawing methods that can be invoked todraw part of a component on a GUI display. The widget class typicallycontains code which invokes drawing methods of the look object class.The look object class may also export properties which provide datarelating to elements of a component.

The look object class may be a default class which provides a defaultlook for widgets in a GUI display. Alternatively, the look object classmay be a class derived from a default class, the derived classoverriding one or more methods and/or properties of the default class.By this arrangement, a user or a developer can make changes to just alimited number of elements within the look of a GUI without having tore-work any parts which are to remain unchanged.

The look object class instance may be a property of the widget classinstance. Typically, a pointer to an instance of the look object classis assigned to a property of the widget class instance. Such a pointermay be passed as an argument to a constructor of the widget class.

The invention also provides a method of creating an object in agraphical user interface in which a look object class is instantiated inwhich is defined properties and/or methods which control the look objectof the object; and a widget class is instantiated which is definedproperties and/or methods which control operation of the object.

In a method according to the last-preceding paragraph, a pointer to thelook object class is typically stored in instance memory of the widgetclass instance.

By controlling operation, it is not necessarily meant that the object isfunctional; whereas sliders and buttons and the like may be capable ofperforming actions, some graphical objects may simply be decorative,such as symbols or parts of composite objects. Thus the propertiesand/or methods which control operation of the object may do little morethan determine the basic function of the object (for example to appearas a pointer), with the precise appearance being controlled by the lookobject.

In another aspect, the invention provides a method of creating aplurality of objects in a graphical user interface in which a lookobject class is instantiated in which look object class is definedproperties and/or methods which control the look of the objects; and awidget class is instantiated a plurality of times in which is definedproperties and/or methods which control operation of the object.

In another aspect, the invention provides a method of implementing agraphical user interface display for an application execution device(for example, a computer, a receiver/decoder for a digital televisionsignal, or another device) comprising loading a widget set as describedabove into memory of the appliance, creating a plurality of objects inthe graphical user interface by a method as described above, anddisplaying the objects on the display.

In such a method applied to a receiver/decoder, the widget set may beloaded into memory of the receiver/decoder by being downloaded in achannel within a digital television signal.

In another aspect, the invention provides a method of updating theappearance of a graphical user interface display for an applicationexecution device, which display includes a widget set as describedabove, in which at least one look object class is replaced by anotherlook object class.

In another aspect, the invention provides a method of updating theappearance of a graphical user interface display of a receiver/decoderfor a digital television signal, which display includes a widget set asdescribed above stored in memory of the receiver/decoder in which atleast one replacement look object class is transmitted to thereceiver/decoder in a channel being part of a digital television signalto replace a stored look object class.

The invention extends to corresponding apparatus. In particular, theinvention extends to a receiver/decoder arranged to perform a method ofany preceding aspect.

In another aspect, the invention provides an application executiondevice (for example, a computer, a receiver/decoder for a digitaltelevision signal, or another device) for implementing a graphical userinterface, comprising a processor, memory, and an output port foroutputting a signal to a display, the memory having stored therein aprogram for carrying out any of the methods described above, or any ofthe objects described above, or any of the widget sets described above.

In any of the above cases, the look object or look object classpreferably defines how at least one of the following properties (ifpresent) of a graphical object are displayed:—

-   -   the background appearance, for example a background colour;    -   a background overlay, for example a logo;    -   the foreground appearance;    -   a foreground overlay, for example a logo;    -   the appearance of relief or shading;    -   the appearance of an object border;    -   the display of any focus assigned to the object;    -   the display of any highlighting assigned to the object.

The invention also extends to a computer program for carrying out any ofthe above methods, and to a computer readable medium having storedthereon a program for carrying out any of the above methods. Theinvention also extends to an application for a receiver/decoder arrangedto perform a method of any preceding aspect. The invention also extendsto a method or apparatus substantially as described herein withreference to the accompanying drawings.

Design of Displayed Graphical Objects

Most graphical user interfaces (GUIs) display various graphical objects,some of which can be manipulated by a user (“active” objects) and somewhich cannot (“static” objects). Preferably, as is described above, thedisplayed graphical objects are preferably designed to complement eachother to produce a coherent design scheme. For example, the displayedgraphical objects preferably share a main colour and texture and font,where appropriate. A design scheme is called herein a “look” of thegraphical objects.

In some cases, only the look of the active graphical objects can bealtered by the user. According to an aspect of the present invention,preferably the look of static graphical objects is alterable. Accordingto an aspect of the invention, preferably the look of a group ofgraphical objects is alterable. Thus a coherent design of the displayedgraphical objects can be obtained.

With reference to other aspects of the invention, where graphicalobjects and link elements are displayed, preferably both the look of thegraphical objects and of the link elements are changeable. Preferablythe look of both the graphical objects and the link elements are thesame in the look selectable by the user. In this way a coherent look fordisplayed chains of graphical objects can be achieved.

In preferred aspect of the invention, the look of the chain isselectable independently of the look of other graphical objectsdisplayed.

An aspect of the invention comprises a method of controlling theappearance of a plurality of graphical objects in a graphical userinterface, the method comprising associating a look object with aplurality of graphical objects.

In a preferred embodiment of the invention, the plurality of graphicalobjects comprises a linked chain. Thus preferably, a particular look ordesign can be applied to the chain or linked list as a whole.Preferably, the look or design can be applied to the chain, linked listor graphical object independently of any look or design applied to otherchains, linked lists or graphical objects.

An aspect of the invention provides a method of displaying a group ofgraphical objects, the method including the step of providing means fordefining a plurality of different displayable groups of graphicalobjects and for selecting a group of graphical objects from theplurality of displayable groups.

Preferably the method comprises defining a displayable group ofgraphical objects and associating a look object with the group ofgraphical objects.

According to the invention there is provided a method of controlling theappearance of a group of graphical objects, the method includingdefining a displayable group of graphical objects.

Also provided is an apparatus for controlling the appearance of a groupof graphical objects, the apparatus including means for defining adisplayable group of graphical objects.

Preferably the representation of graphical objects from a group differfrom the representation of graphical objects of another group, forexample in one or more of colour, shape, size, texture or pattern.

Preferably the group of graphical objects comprises elements fordisplaying a linked chain of graphical objects.

Preferably the group of graphical objects comprises static objects andactive objects. Thus the apparatus may comprise a library of groups ofgraphical objects, preferably having different looks or designs.

Preferably, displayed graphical objects from a first group differ fromdisplayed graphical objects of another group in one or more of colour,shape, size, texture or pattern. The arrangement of the graphicalobjects in the first group may differ from the arrangement of thegraphical objects in another group.

In accordance with a preferred embodiment of the invention, the group ofgraphical objects comprises a linked chain of graphical objects.Preferably, the linked chain is displayable as a linked chain in theGUI.

Other preferred features of this aspect of the invention are describedabove under the heading Displaying Graphical Objects.

Building Graphical Objects

Most graphical user interfaces (GUIs) include various graphical objects,some of which can be manipulated by a user. Such graphical objectsinclude windows, dialog boxes and push-buttons. The GUI generallyincludes several different types of each graphical object, for examplethe GUI may be arranged for the display of a large variety of dialogboxes having different sizes and/or aspect ratios.

Where a GUI has, for example, two types of dialog box, one being halfthe size of the other, each type of box is formulated and saved in thesystem as a separate object. Where the GUI includes a large number ofdifferent types of dialog box and/or different types of other graphicalobjects, that can lead to inefficient use of system resources.

An aspect of the invention provides a method of controlling theappearance of a graphical object in a graphical user interface, themethod comprising defining a plurality of graphical object elements ofthe graphical object for use in displaying a representation of thegraphical object.

An aspect of the invention provides a graphical object element beingadapted for combination with other graphical object elements to form thegraphical object.

Where the GUI includes a number of different types of the same graphicalobject, the different types will often have features in common withother types of the object. For example, windows and boxes of differentsizes will often have the same corners as each other, the differencebetween the different types of boxes being only in the length of theedges of the box. By providing object elements for building thegraphical objects, advantage can be taken of the common features of thevarious objects so that a few building blocks (the object elements) canbe used to create a large number of different types of the graphicalobject.

The graphical object may comprise, for example, a window, a dialog box,a push-button, a scroll-bar, an icon or other on-screen object. Thegraphical object may be “active” in that the user can interact with itor “static”, for example features of the background.

An aspect of the invention provides a graphical object comprising aplurality of graphical object elements.

An aspect of the invention provides a method of displaying arepresentation of a graphical object in a graphical user interface, themethod comprising assembling a plurality of graphical object elements toform the graphical object.

An aspect of the invention provides apparatus for forming a graphicalobject in a graphical user interface, the apparatus comprising means forassembling a plurality of graphical object elements to form thegraphical object.

An aspect of the invention provides an application execution device forimplementing a graphical user interface, comprising a processor, memory,and an output port for outputting a signal to a display, the memoryhaving stored therein a program for carrying out an aspect of theinvention.

Preferably the application execution device comprises a receiver/decoderof a digital television.

An aspect of the invention provides a computer program for carrying outa method of the invention.

The graphical object elements of a graphical object may all be the same,the size and shape of the graphical object being determined by thenumber and configuration of the elements.

Preferably, the graphical object includes a plurality of different setsof graphical object elements. Preferably, the method aspect includesdefining a plurality of different sets of graphical object elements ofthe graphical object.

A set of graphical object elements may comprise, for example, corner,side or edge portions of the graphical object. For example, where thegraphical object is a dialog box, the sets of graphical objects used tomake up the box may comprise corner elements and edge elements. Forexample, a rectangular box may comprise four corner elements and fouredge elements which link together the corner elements.

Within each set of elements, there may be different types of elements,for example having a different size, shape, orientation and/or colour.Thus the example of the box may comprise four types of corner elementsand two types of edge elements.

A push-button may comprise two side elements and a centre element whichis chosen depending on the type of push-button the graphical object isto be. For example a PLAY button may have a centre element including anarrow symbol, a STOP button may have a centre element including a squaresymbol. The side elements of the PLAY button may be the same as the sideelements of the STOP button.

A library of object elements can also be used to form graphical objectshaving relatively complex shapes. For example a variety of complexmatrices of dialog boxes could easily be formed from a selection ofobject elements comprising box edges, corners and intersection points.

In a preferred embodiment of the invention, the graphical objectincludes at least two “corner” elements which define the “corners” or“sides” of the graphical object and a plurality of filler elements, thenumber of which can be varied to vary the size and/or shape of thegraphical object. Thus, a text box preferably has four corner elementsand a plurality of filler elements are used to fill the box between thecorner elements to create the box of the desired size. The fillerelements may all be the same. In the embodiments below, different typesof filler elements are used, for example centre elements and four typesof edge elements, to build boxes and windows.

Preferably the filler elements are repeated to build up the requiredsize and shape of the graphical object.

The method preferably includes defining a set of fixed elements and aset of repeatable elements.

The invention also provides a method of forming a graphical object, themethod comprising providing a set of fixed elements and a set ofrepeatable elements.

For example, for a window or box, the set of fixed elements may comprisethe corners and any ornamentation for the box, those fixed elementsbeing fixed for all boxes or windows of that sort, of whatever size; theset of repeatable elements are used to build up the required size andshape of the object. Preferably, only one of each fixed element isrequired for each instance of the graphical object. Thus the set ofrepeatable elements may include edge segments and centre pieces whichare used to fill in between the corners.

The size of the repeatable elements are preferably chosen so that thenumber of types of repeatable elements for a particular object isminimised. For example, the size of the repeatable elements arepreferably chosen having regard to the smallest size of the graphicalobject required. Thus the memory taken up in the storage of the “skit”required to build each graphical object can be reduced.

The invention also provides a kit of elements for a graphical object,the kit comprising a set of fixed elements and a set of repeatableelements.

The invention also provides a method of producing a kit of elements fora graphical object, the method comprising defining a set of fixedelements common to instances of the graphical object and furtherdefining a set of repeatable elements.

The size of an object element may be adjustable. Thus fewer types ofobject elements are required to create a wide range of objects. For theexample of the dialog box, the length of the edge elements may beadjustable. In this way, a large number of different box shapes could becreated using just the four corner elements and two types of edgeelements (in this case vertical edge elements of adjustable length andhorizontal edge elements of adjustable length).

The invention further provides a method of displaying a representationof a graphical object in a graphical user interface, the methodcomprising assembling a plurality of graphical object elements.

Preferably the method comprises displaying a set of fixed elements anddisplaying a plurality of repeatable elements.

The invention further provides apparatus for controlling the appearanceof a graphical object in a graphical user interface, the apparatuscomprising means for defining a plurality of graphical object elementsof the graphical object for use in displaying a representation of thegraphical object.

Further provided by the invention is a kit of elements for use indisplaying a graphical object, comprising a set of fixed elements commonto instances of the graphical object and a set of repeatable elements.

The invention further provides apparatus for displaying a representationof a graphical object in a graphical user interface, the apparatuscomprising means for assembling a plurality of graphical objectelements.

The invention is of particular advantage in the application of theinvention to wide-screen television; the aspect ratio of the graphicalobjects can be easily adjusted by changing the number or size of thegraphical object elements compared with the graphical object for astandard television.

The invention also allows variations in the graphical objects to be madeeasily, for example embellishments and ornamentations. An object elementmay comprise an ornamentation to be included on dialog boxes. A hugevariety of different objects having different or the same ornamentationcan be created using the present invention.

Tool Tips and Menu Chains

Graphical user interfaces (GUIs) generally include various graphicalobjects, some of which can be manipulated by the user (“active”objects), and others which cannot (“static” objects). The graphicalobjects, in particular active objects, are often identified to the userby icons which may comprise pictures or diagrams illustrating what thegraphical object is. For example, a button for carrying out a PLAYfunction may include an icon comprising an arrow. Such icons can improvethe visual appearance of the graphical objects as well as assisting ineasy navigation of the display.

In particular, where screen space is as a premium, icons areparticularly useful. An example is a GUI used for a receiver/decoder fora digital television in which the icons are on-screen icons for use inthe operation of the television and/or for other on-screen functions,for example web browsing. The resolution of a standard television screenis relatively low and, for legibility, any data appearing on the screenis required to be relatively large. Also, users of a television setgenerally sit further from the screen when using the television thanthey would when using, for example, a personal computer. Thus any iconsand text appearing on the screen are required to be relatively large.

This imposes restraints on the amount of information that can bedisplayed on the screen at once. Thus the use of icons is particularlyadvantageous.

Effort is made to choose icons which clearly depict what the graphicalobject does. However, some users may be unfamiliar with the icon usedand may be unsure what the feature represents. However, it would beundesirable to have the graphical objects being identified on the screenby a text explanation, because the screen may become too cluttered.

An aspect of the invention provides a method of controlling theappearance of a graphical object in a GUI, the method comprisingdefining a first displayable representation of a graphical object andfurther defining a second displayable representation of the graphicalobject, the second representation being displayable adjacent the firstrepresentation.

An aspect of the invention provides a method of displaying a graphicalobject on a GUI, the method comprising displaying a first representationof a graphical object and displaying a second representation of thegraphical object adjacent the first representation.

The first representation preferably comprises an icon. Preferably thesecond representation is selectively displayed.

Preferably, the first representation is active, so that activating orselecting the first representation carries out an action of thegraphical object. For example the first representation may be apush-button. Preferably, the second representation is a text descriptionof the graphical object, for example a word indicating the function ofthe object. The second representation may or may not be active.

The second representation is preferably only selectively displayable.Thus, preferably, the second representation of the graphical object doesnot appear on the screen all the time, only when of assistance to theuser.

Preferably the second representation displayable by focussing on thefirst representation. For example the second representation may only bedisplayed when the user has focussed on the first representation, forexample by moving a focus to it using cursor keys, or by moving a mousepointer to point to it.

Preferably the text representation of the graphical object is displayedwithin a frame, for example in a box or in a window. Preferably thedesign of the frame complements or is matched to the design of othergraphical objects displayed, especially other representations of thesame graphical object. Thus a coherent design scheme can be obtained.Preferably the second representation is linked to the firstrepresentation, for example by linking the box or window to the firstrepresentation. Thus the user can see more clearly exactly to what thetext description applies.

Preferably the method includes defining a link element for linking thefirst representation and the second representation. Preferably themethod includes associating a look object with the first representation,the second representation, and preferably the link element. Thuspreferably the first and second representations and the link elementshare features of, for example, colour, texture, and shape to give acoordinated look. The look object may comprise a plurality of separatelook objects, so that a coordinated look can be obtained for the variousrepresentations and link elements.

The invention further provides a method of displaying a graphicalobject, the method comprising displaying a first representation of thegraphical object, displaying a second representation of the graphicalobject, and displaying a link element linking the first representationand the second representation.

The invention provides apparatus for controlling the appearance of agraphical object in a GUI, the apparatus comprising means for defining afirst displayable representation of a graphical object and means fordefining a second displayable representation of the graphical object,and means for displaying the second representation being adjacent thefirst representation.

Preferably the apparatus includes means for selectively displaying thesecond representation, preferably when detecting a focus on the firstrepresentation.

According to the invention, there is also provided apparatus fordisplaying a graphical object, the apparatus comprising means fordisplaying a first representation of the graphical object, means fordisplaying a second representation of the graphical object, and meansfor displaying a link element linking the first representation and thesecond representation.

Where the graphical object is in a chain or linked list as describedbelow, preferably the second representation is a part of the displayedchain or linked list. Preferably the method includes defining a linkedchain of graphical object, the first and second representations beingdisplayable as links of a chain of representations of graphical objects.

Preferably the second representation is in a sub-chain. Preferably thesub-chain branches from the first representation.

An aspect of the invention provides a display including a graphicalobject, the graphical object comprising a first representation of thegraphical object and, preferably selectively displayable, a secondrepresentation of the graphical object adjacent the first representationof the graphical object.

An aspect of the invention provides apparatus for controlling theappearance of a graphical object in a graphical user interface,comprising means for defining a first representation of the graphicalobject and means for defining a second representation of the graphicalobject, the second representation being displayable adjacent the firstrepresentation.

An aspect of the invention provides an application execution device forimplementing a graphical user interface, comprising a processor, amemory and an output port for outputting a signal to a display, thememory having stored therein a program for carrying out an aspect of theinvention.

Preferably the application execution device comprises a receiver/decoderof a digital television.

Also provided is a computer program for carrying out a method of theinvention.

For GUIs of computers and other apparatus, the user is usually providedwith a mouse or other pointer device for navigating around the displayand manipulating the displayed graphical objects. However, in someapplications, for example television receiver/decoder apparatus andmobile telephones and personal organisers, the user might not have apointer device. For example, the user might use a cursor keypad tonavigate around the display. Such cursor keypads usually include up,down, left and right keys. It can be confusing for the user to navigatearound the display using only those keys, in particular where displayedgraphical objects on the screen are not arranged in obvious lines and/orcolumns.

An aspect of the present invention provides a method of controlling theappearance of graphical objects in a graphical user interface, themethod comprising defining a linked chain of graphical objects.

An aspect of the present invention provides a method of controlling theappearance of a graphical object in a graphical user interface, themethod comprising defining a first graphical object, defining a secondgraphical object and defining a link element for linking the graphicalobjects.

An aspect of the present invention provides apparatus for displayinggraphical objects in a GUI, the apparatus comprising means fordisplaying a plurality of graphical objects and means for displayinglink elements between graphical objects.

An aspect of the invention provides a graphical object and a linkelement associated with the graphical object.

An aspect of the invention provides a method of displayingrepresentations of graphical objects in a graphical user interface(GUI), the method comprising displaying representations of graphicalobjects and displaying a representation of a link element forillustrating a link between graphical objects.

Preferably, the displayed link element extends from one graphical objectto another. Preferably, the method includes displaying a linked chain ofrepresentations of graphical objects.

Preferably the method further includes defining a sub-chain of graphicalobjects, the sub-chain comprising a branch from a linked chain,preferably the sub-chain being selectively displayable.

Preferably, the method further includes displaying graphical objects ina sub-chain, the sub-chain preferably comprising a branch of the linkedchain, and preferably the sub-chain is displayable by focussing on agraphical object in the linked chain. Thus the sub-chain might only bedisplayed when of interest to the user, thus reducing cluttering of thedisplay.

An aspect of the invention provides a method of displaying graphicalobjects in a GUI, the method comprising displaying a plurality ofgraphical objects as a linked list. Thus, an aspect of the inventionprovides graphical objects which can be navigated using a cursor keypad.Preferably, the displayed graphical objects comprise icons. Preferablythe links between the graphical objects are displayable.

The displayed link element may extend from one graphical object toanother to indicate a path between them. This is of particular advantagewhere the user is using cursor keys to navigate the display rather thana mouse. In some cases, however, the link element might not extendacross the whole distance between graphical objects, while stillproviding an indication to the user of a path between the graphicalobjects. For example, the link element might comprise an arrow on anicon pointing to the next icon in the path.

An aspect of the invention provides a chain of graphical objects. Morethan one link element may be provided for each graphical object,indicating a choice of navigation paths from that object. Thus abranched network or tree structure of graphical objects and linkelements can be formed, the network being easily navigable by the user,even without the use of a mouse. Also provided by an aspect of theinvention is a network of graphical objects.

An aspect of the invention provides a main chain of graphical objectsand a sub-chain of graphical objects branched from the main chain.Preferably, the representations of the graphical objects are buttons.(As used herein the term “button” is preferably to be interpretedbroadly to refer to any graphical object which carries out a functionwhen selected.)

Preferably, a plurality of sub-chains are displayable. Preferably asub-chain is displayable by selecting a graphical object of the mainchain.

Preferably the sub-chain extends substantially perpendicular to the mainchain.

Where, in accordance with another aspect of the invention, a secondrepresentation of the graphical object is displayable adjacent thegraphical object, preferably the second representation of the graphicalobject is displayable as a part of the sub-chain of the firstrepresentation of the graphical object. Thus, where the secondrepresentation of the graphical object is a text box including adescription of the graphical object, the sub-chain will preferablyinclude the text box and description in the sub-chain. This can be ofassistance to the user.

According to an aspect of the invention there is provided an apparatusfor displaying a graphical object, the apparatus comprising means fordisplaying a first representation of the graphical object, means fordisplaying a second representation of the graphical object, and meansfor displaying a link element linking the first representation and thesecond representation.

Also provided is an apparatus for controlling the appearance ofgraphical objects in a graphical user interface, the apparatuscomprising means for defining a linked chain of graphical objects.

Also provided is apparatus for controlling the appearance of a graphicalobject in a graphical user interface, the apparatus comprising means fordefining a first graphical object, defining a second graphical objectand defining a link element for linking graphical objects.

The invention also provides apparatus for displaying representations ofgraphical objects in a graphical user interface, the apparatuscomprising means for displaying representations of graphical objects andmeans for displaying a representation of a link element for illustratinga link between graphical objects.

Also provided by the invention is an object in a graphical userinterface comprising a first representation of a graphical object and asecond representation of a graphical object, and a link element linkingthe first and second representations; an object in a graphical userinterface comprising a linked chain of graphical objects; and an objectin a graphical user interface comprising a first graphical object, asecond graphical object and a link element linking the first and secondgraphical objects. Preferably the object further includes a sub-chain ofgraphical objects, the sub-chain comprising a branch from a linkedchain, preferably the sub-chain being selectively displayable.

An aspect of the invention includes an application execution device forimplementing a graphical user interface, the device comprising aprocessor, memory and an output port for outputting a signal to adisplay, the memory having stored therein a program for carrying out anaspect of the invention.

The aspect of the invention also includes a computer program forcarrying out a method of the invention.

Head to Tail Flipflop

Most graphical user interfaces (GUIs) include various graphical objects,some of which can be manipulated by a user. Such graphical objects areoften displayed as icons which normally comprise pictures or diagramsillustrating what the graphical object is. For example, an object forcarrying out a PLAY function may be displayed as an icon including anarrow. An object for effecting printing may comprise a diagram of aprinter. Such icons can improve the visual appearance of the displayedgraphical objects as well as assisting in easy navigation of the GUI.

Effort is made to choose icons which clearly depict what the graphicalobject does. Many “standard” icons are used and are generallyrecognisable as being icons depicting “forward”, “go back”, “play” and“stop”. However, some users may be unfamiliar with the icon used andwill be unsure what the feature represents.

An aspect of the invention provides a graphical object having a featuredisplayed, wherein the feature is displayable in a plurality of forms,and means for changing the form in which the feature is displayed.

Preferably, one form of in which the feature is displayed is an icon.For example a PLAY button may be in the shape of an arrow.

An aspect of the invention comprises a method of controlling theappearance of a graphical object in a GUI, the method comprisingdefining a first representation of the graphical object and a secondrepresentation of the graphical object, the first and secondrepresentations being selectively displayable, preferably cyclicallydisplayable.

An aspect of the invention provides a method of displaying a graphicalobject in a GUI, the method comprising displaying a first representationof the graphical object and subsequently displaying a secondrepresentation of the graphical object.

Preferably, the first representation of the graphical object includes anicon. Preferably, the second representation of the graphical objectincludes a text description of the graphical object. Preferably, thedisplay of the graphical object cycles between the first representationand the second representation.

An aspect of the invention provides apparatus for controlling theappearance of a graphical object in a GUI, the apparatus comprisingmeans for defining a first representation of the graphical object andmeans for defining a second representation of the graphical object.

An aspect of the invention provides application execution device forimplementing a graphical user interface, the device comprising aprocessor, memory and an output port for outputting a signal to display,the memory having stored therein a program for carrying out an aspect ofthe invention.

Preferably the application execution device comprises a receiver/decoderof a digital television.

Also provided is a computer program for performing a method of theinvention.

The different representations which may be displayed include, forexample, an icon and a text description of the feature. Thus a PLAY icon(for example a illustration of an arrow) may also be displayable as theword “play”. Thus the visual and other benefits of the use of the iconcan be obtained while ensuring that the user knows the meaning of theicon from the text description. By providing the differentrepresentations of the graphical object, the visual appearance of theGUI can be improved and the different displays do not clutter the user'sviewable area.

In a first embodiment of the invention, the representation of thegraphical object to be displayed can be set by the user. For example,the user might be familiar with the icons used and not require a textexplanation of the icons. In this case he may select that only the iconsbe displayed.

In a second embodiment of the invention, the representation displayedcan be changed by the user by selecting or focussing on (for examplehighlighting) the displayed representation. For example, if therepresentation is set to the graphical object as the “PLAY” icon, theuser can change the “PLAY” icon to the text “play” by focussing on, forexample highlighting or selecting, the first representation.

In a third embodiment of the invention, the display of the graphicalobject switches between the different representations withoutintervention by the user. For example, the preferences can be set sothat the displayed graphical object cycles between two types ofrepresentation. In a preferred embodiment, the display cycles betweenthe icon and the text description. The cycle time may be adjustable. Anexample of a cycle time is about 2 seconds.

In an embodiment of the invention, a timer is started when arepresentation is displayed; when the timer reaches a predeterminedvalue, the representation changes. The change of representation may bedirectly from one representation to another, for example from the iconto the text description, or may comprise a sequence of representations.For example, the sequence of representations may show a progressivechange from one representation to another. In an embodiment, thesequence of representations gives the effect that the tworepresentations are on opposite faces of a spinning coin.

The invention further provides apparatus for controlling the appearanceof a graphical object in a GUI, the apparatus comprising means fordefining a first representation of the graphical object and a secondrepresentation of the graphical object, and means for selectivelydisplaying the first and second representations, and preferably meansfor cyclically displaying the first and second representations.

Also provided is apparatus for displaying a representation of agraphical object in a GUI, the apparatus comprising means for displayinga first representation of the graphical object, and means forsubsequently displaying a second representation of the graphical object.

Preferably the apparatus further comprises means for displaying asequence of representations between the displaying the first and secondrepresentations.

The invention further provides an object in a GUI comprising a firstrepresentation of the graphical object and a second representation ofthe graphical object, the first and second representations beingselectively displayable, preferably cyclically displayable.

On-Screen Keyboard

Devices having numeric keypads are being used more and more to carry outtasks which involve writing data including text using the keypad. Forexample, mobile telephones are used to enter information into thetelephone memory, for example names into telephone books in the phone,or the sending of text messages. Other examples include televisionremote controls used to enter text onto a television screen, for examplewhen accessing the Internet using a television having areceiver/decoder.

Such devices normally have only numeric keypads having a key for each ofthe numbers 0 to 9 and possibly a few other keys, for example # and *.In order to be able to enter text, at least 26 additional key functionsare required for the letters of the alphabet, with still further keyfunctions required where both upper and lower case letters, punctuationand symbols as well as accented letters are required.

In known keypads used for text entry, each key of the keypad is assigneda number of functions, and the user cycles through the availablefunctions by pressing the key several times, the different functionsusually being viewable on a display. When the user reaches the desiredfunction for the key, the function is selected, usually by pressing a“select” key or by moving the display cursor. It will be seen that,where a full set of functions is to be made available, each key of thekeypad necessarily relates to several different functions. For example,the “2” key of a keypad may include the following functions:

-   -   A, B, C, a, b, c, 2, Ä, ä, Á, á, Â, â, À, à, {dot over (A)},        {dot over (a)}, AE, ae,        and ç        and may further include symbol functions. Each time a particular        letter, number or symbol is required, the key has to be pressed        several times. This clearly can be time consuming and        inefficient. Also, design restraints and the physical size of        the keys often dictate that not all of the letters and symbols        which can be accessed by a particular key can be displayed to        the user. Thus, if the user wishes to enter a particular letter        or symbol, he often has to use trial and error to find the key        which activates it.

A solution which is used for some models of mobile phones is to includea QWERTY keyboard, but clearly that is not ideal where a small keypad isdesirable; the keys must remain large enough for use.

An aspect of the invention provides, a keypad having keys for performingfunctions, each key including a function option, wherein the functionoption of the key is changeable.

In an embodiment of the invention, each key has only one function optionat a time, so that the key need only be pressed once to carry out thatfunction. By providing that the functions options of the keys arechangeable, it is still possible to use the keypad to carry out morefunctions than there are keys, but the efficiency of use can beimproved.

Preferably, a set of options is arranged as a template for the keypad,the template being changeable. For example, if the keypad is to be usedin one task for typing only numbers, it would be inefficient if, foreach number to be typed, the user had to scroll through 3 or moreletters. By changing the options of all the keys of the keypad to“numbers”, a key need only be pressed once by the user to type therequired number. Similarly, if the user wishes to type in capitals, the“capitals” template can be applied to the keypad. Thus only capitalletters will be included in the options for the key functions, reducingthe number of functions through which the user must scroll to find thedesired one.

Preferably, the key options are changed for the keypad as a whole but,alternatively, the options for only some of the keys might be changed.

An aspect of the invention provides a method aiding entry of data into agraphical user interface (GUI) using a keypad, the method comprisingdefining a plurality of templates, each template comprising a set offunctions for the keypad.

An aspect of the invention provides apparatus for use in entering datainto a graphical user interface using a keypad, the apparatus comprisinga plurality of templates, each template comprising a set of functionsfor the keypad.

Preferably the templates are displayable on a display.

Preferably, a number of different templates are provided, and the methodincludes the step of selecting a template for use. Preferably theapparatus further comprises means for selecting a template. Thedifferent templates preferably provide different function sets for thekeypad. For example, a template may provide the capital letters A to Jfor the number keys of the keypad. A different template may provide thecapital letters K to T, and so on.

In embodiments of the invention described herein, the templates eachinclude only 10 functions, for use with ten keys of the keypad. In adifferent embodiment, the keypad may include more keys and it may bepossible to represent the whole alphabet on the template. For example,the keypad may comprise a keyboard. Different templates may be providedcorresponding to different types of keyboard, for example differentlanguage variants, different numbers and arrangement of keys, andsymbols and other characters. All the required functions might beincluded on each template, the different templates being providedcorresponding to different key layout of different types of keypad orkeyboard.

The term keypad used herein is preferably to be interpreted broadly toinclude all devices having an array of keys or buttons or the like. Thusthe term preferably includes remote controllers, telephones and computerkeyboards as well as other devices.

Preferably the method includes the step of displaying the template, forexample on the screen of a computer or television. Preferably aplurality of available templates are displayed and preferably the useris able to choose one of the displayed templates for use.

In a preferred embodiment, the available templates are displayed as agrid, and preferably the user selects the desired template using thecursor keys of the keypad. The user may alternatively use a differentdevice, for example a pointer device, for example a mouse.

Preferably, the display shows the functions of the template in aconfiguration corresponding to the arrangement of the relevant keys ofthe keypad. Preferably, the method includes displaying an image of akeypad. Preferably the step of selecting the template includes movingthe image of the keypad relative to the templates on the screen.

Preferably the apparatus further includes a displayable keypad image,the apparatus preferably providing means for moving the keypad imagerelative to a display of the templates.

Preferably, the displaying of the image of the keypad on the screenincludes the step of selecting the image of the keypad to be displayed.The layout of keys on a keypad can vary from one type of keypad toanother and thus it is advantageous for the layout of keys on thetemplate shown to correspond to the keypad layout.

Preferably the user moves the image of the keypad relative to thetemplates using cursor keys on the keypad.

The functions of the templates may be set out as QWERTY keyboards, thekeyboard being split into various zones for the image of the keypad. Forexample, in one position, the keypad may be used to enter the letters q,w, e, a, s, d, z, x, c and SPACE.

In other embodiments, the functions of the templates are set out inother ways. Preferably, functions used often by the user are arranged sothat they appear on more than one template. Preferably, the templatesmay be customised by the user.

The functions provided by a key of the template keyboard may comprisemore than one letter, number or symbol. For example, where the keypad isused for a web browser, a key may be used to enter a text string, forexample “http:\” or “www”.

Preferably, the keypad template is displayed on the screen while theuser enters the data.

An aspect of the invention provides a template for a keypad. Preferablythe template is displayable in a GUI.

An aspect of the invention provides a method of entering data using akeypad, the method including selecting a template comprising a set offunctions for the keypad.

The aspect of the invention further provides apparatus for entering datausing a keypad, the apparatus including means for displaying a keypadtemplate. Preferably the apparatus includes means for displaying aplurality of keypad templates and means for selecting a template.

Preferably the display of the keypad templates for data entry isseparate from any other application that the apparatus may be running.For example, if the apparatus is running a web browser application anddata needs to be entered in a dialog box, the user calls up the keypadtemplates which runs parallel to the browser application. Preferably,the keypad template application can be called from a plurality ofapplications in the apparatus.

The aspect of the invention also provides an application executiondevice for implementing a graphical user interface, comprising aprocessor, memory and an output port for outputting a signal to adisplay, memory having stored therein a program for carrying out anaspect of the invention. Preferably, the memory further has storedtherein a library of keypad templates and preferably further has storedtherein a library of keypad images.

The aspect of the invention further provides a library of keypadtemplates and/or keypad images.

An aspect of the invention provides a computer program for carrying outa method of the invention.

General

Where reference is made herein to graphical and other objects, such termis to be interpreted broadly. In particular, it should not beinterpreted as implying that the objects are defined by object-orientedprogram code.

The methods described herein are preferably carried out using anapplication execution device having a suitably programmed processor.

Preferably the inventions relate to the broadcasting and receiving oftransmissions.

Any of the methods above may be carried out by a receiver/decoder, suchas a digital or analogue television receiver/decoder. Alternatively, themethods may be carried out by a mobile telephone, a computer, or anotherdevice.

The inventions described herein also extend to a computer program forcarrying out any of the described methods, and to a computer readablemedium having stored thereon a program for carrying out any of the abovemethods. The invention also extends to an application for areceiver/decoder arranged to perform a method of any aspect of theinvention.

The inventions also extend to computer program products, for examplecomprising computer software and/or computer software upgrades. Suchcomputer program products may be, for example, transmitted to a userfrom a broadcast centre by, for example cable or satellite broadcast.The computer program products may be provided on a disc, for example aCD ROM. The computer program product may be tangibly embodied forexample as software stored on a storage medium such as a hard disk orvolatile or non-volatile memory, or as a signal.

Thus aspects of the invention further provide: a computer programproduct comprising code for:

defining a look object; and

associating the look object with the graphical object; a computerprogram product for use in defining a graphical object in a graphicaluser interface comprising:

code for providing a look object which controls the appearance of thegraphical object; and

code for providing a widget object which controls operation of thegraphical object; a computer program product for use in a method ofcontrolling the appearance of a group of graphical objects, includingcode for defining a plurality of different displayable groups ofgraphical objects and for selecting a group of graphical objects fromthe plurality of displayable groups; a computer program product for usein a method of controlling the appearance of a group of graphicalobjects, comprising code for defining a displayable group of graphicalobjects; a computer program product for use in a method of controllingthe appearance of a graphical object in a graphical user interface,comprising code for defining a plurality of graphical object elements ofthe graphical object for use in displaying a representation of thegraphical object; a computer program product for use in a method ofproducing a kit of elements for a graphical object, comprising code fordefining a set of fixed elements common to instances of the graphicalobject and for defining a set of repeatable elements; a computer programproduct for use in a method of displaying a representation of agraphical object in a graphical user interface, comprising code forassembling a plurality of graphical object elements; a computer programproduct for use in a method of controlling the appearance of a graphicalobject in a GUI, comprising code for defining a first displayablerepresentation of a graphical object and for defining a seconddisplayable representation of the graphical object, and code fordisplaying the second representation adjacent the first representation;a computer program product for use in a method of displaying a graphicalobject, comprising code for displaying a first representation of thegraphical object, displaying a second representation of the graphicalobject, and displaying a link element linking the first representationand the second representation; a computer program product for use in amethod of controlling the appearance of graphical objects in a graphicaluser interface, comprising code for defining a linked chain of graphicalobjects; a computer program product for use in a method of controllingthe appearance of a graphical object in a graphical user interface,comprising code for defining a first graphical object, defining a secondgraphical object and defining a link element for linking graphicalobjects; a computer program product for use in a method of displayingrepresentations of graphical objects in a graphical user interface,comprising code for displaying representations of graphical objects andfor displaying a representation of a link element for illustrating alink between graphical objects; a computer program product for use in amethod of controlling the appearance of a graphical object in a GUI,comprising code for defining a first representation of the graphicalobject and a second representation of the graphical object, and code forselectively displaying the first and second representations, preferablycyclically displaying the representations; a computer program productfor use in a method of displaying a representation of a graphical objectin a GUI, comprising code for displaying a first representation of thegraphical object, and for subsequently displaying a secondrepresentation of the graphical object; and a computer program productas herein described for use with a receiver/decoder.

Also provided is a computer program product comprising a memory andprocessor, the memory having stored therein an application, and theprocessor (under the control of the application) being adapted to carryout the any of the methods described herein; a computer program productcomprising a program for carrying out any of the methods describedherein; and a computer program for carrying out any of the methodsdescribed herein.

Also provided by the invention is a computer readable medium havingstored thereon a program for carrying out any of the methods asdescribed herein and a computer readable medium having stored thereon acomputer program product as described herein.

Also provided is a signal tangibly embodying a computer program productas described herein.

The invention further provides a method substantially as hereindescribed with reference to and illustrated in the accompanying drawingsand apparatus substantially as herein described with reference to and asillustrated in the accompanying drawings.

Where aspects of the invention relate to graphical objects, theinvention provides a method of defining the graphical objects, ofcontrolling the appearance of the graphical objects and also todisplaying representations of the graphical objects on a suitabledisplay, for example a television screen or LCD of a mobile telephone,and to the graphical objects themselves. The invention also providesapparatus for carrying out the invention, and the methods of theinvention, preferably using a suitably programmed processor.

Preferably the invention finds application for digital television, andpreferably a web browser for a television. The invention may be embodiedin a receiver/decoder for example for a digital television. Features ofthe aspects of the inventions described above are preferably provided bya processor and/or memory, for example a processor and memory of thereceiver/decoder.

Any of the methods described herein may be carried out by thereceiver/decoder, such as a digital or analogue televisionreceiver/decoder.

The term “receiver/decoder” used herein may connote a receiver forreceiving either encoded or non-encoded signals, for example, televisionand/or radio signals, which may be broadcast or transmitted by someother means. The term any also connote a decoder for decoding receivedsignals. Embodiments of such receiver/decoders may include a decoderintegral with the receiver for decoding the received signals, forexample, in a “set-top box”, such a decoder functioning in combinationwith a physically separate receiver, or such a decoder includingadditional functions, such as a web browser, a video recorder, or atelevision.

It will be understood that the present invention has been describedherein purely by way of example, and modifications of detail can be madewithin the scope of the invention.

Each feature disclosed in the description, and (where appropriate) theclaims and drawings may be provided independently or in any appropriatecombination.

Where features of the apparatus are described herein as “means for” aparticular function, it is intended that those terms be interpretedbroadly and are preferably not interpreted to be limited to anyparticular embodiment of the invention described herein. Features of theapparatus are, in preferred embodiments provided by a suitablyprogrammed computer or computers, and thus features of the apparatus arepreferably provided by the relevant features of a computer or productcomprising a computer program. For example, features of the apparatusmay be provided by a processor, or other part of a computer, for examplea memory or data store.

Features of one aspect may be applied to any other aspect; methodfeatures may be applied to apparatus aspects and vice versa.

Preferred features of the present invention will now be described,purely by way of example, with reference to the accompanying drawings,in which:

FIG. 1 a shows an overview of a typical digital television system;

FIG. 1 b shows the general architecture of the interactive televisionsystem;

FIG. 2 a is a block diagram of a receiver/decoder;

FIG. 2 b shows the architecture of a receiver/decoder;

FIG. 2 c illustrates further the architecture of the receiver/decoder;

FIG. 3 is a diagram of part of the hierarchy of widgets within a widgetset;

FIG. 4 is a simplified diagram of a widget appearing on a GUI display;

FIG. 5 illustrates the location in memory of several widgets FIG. 6 aillustrates a screen display of the web browser,

FIG. 6 b shows a remote control for navigating the web browser;

FIG. 7 illustrates a further screen display of the web browser;

FIG. 8 illustrates a further screen display of the web browser;

FIG. 9 illustrates a further screen display of the web browser;

FIG. 10 illustrates a further screen display of the web browser;

FIG. 11 illustrates a further screen display of the web browser,

FIG. 12 illustrates a further screen display of the web browser;

FIG. 13 illustrates a further screen display of the web browser,

FIG. 14 illustrates a further screen display of the web browser;

FIG. 15 illustrates a further screen display of the web browser;

FIG. 16 illustrates a further screen display of the web browser;

FIG. 17 illustrates a further screen display of the web browser;

FIG. 18 illustrates a further screen display of the web browser;

FIG. 19 illustrates a further screen display of the web browser;

FIG. 20 illustrates a further screen display of the web browser;

FIG. 21 illustrates a further screen display of the web browser;

FIG. 22 illustrates a further screen display of the web browser,

FIG. 23 illustrates a further screen display of the web browser;

FIG. 24 illustrates a further screen display of the web browser,

FIG. 25 illustrates a further screen display of the web browser;

FIG. 26 illustrates a further screen display of the web browser;

FIG. 27 illustrates a further screen display of the web browser;

FIG. 28 illustrates a further screen display of the web browser;

FIG. 29 illustrates a further screen display of the web browser;

FIG. 30 illustrates a further screen display of the web browser;

FIG. 31 is an example of a graphical object formed by tiling;

FIG. 32 is a further example of a graphical object formed by tiling;

FIG. 33 is a further example of a graphical object formed by tiling;

FIG. 34 is a further example of a graphical object formed by tiling;

FIG. 35 is a further example of a graphical object formed by tiling;

FIG. 36 is a further example of a graphical object formed by tiling;

FIG. 37 is a further example of a graphical object formed by tiling;

FIG. 38 is a further example of a graphical object formed by tiling;

FIG. 39 illustrates the method of tiling graphical objects;

FIG. 40 shows a typical image buffer,

FIG. 41 shows the layout of a tiled graphical object.

FIG. 42 schematically illustrates the operation of a virtual keyboard;

FIG. 43 shows a typical mapping of characters to keys on a virtualkeyboard;

FIG. 44 shows examples of a virtual keyboard; and

FIG. 45 shows typical dimensions of a virtual keyboard.

OVERVIEW OF A DIGITAL TELEVISION SYSTEM

An overview of a digital television system 1 is shown in FIG. 1 a. Theinvention includes a mostly conventional digital television system 2that uses the known MPEG-2 compression system to transmit compresseddigital signals. In more detail, MPEG-2 compressor 3 in a broadcastcentre receives a digital signal stream (typically a stream of videosignals). The compressor 3 is connected to a multiplexer and scrambler 4by linkage 5.

The multiplexer 4 receives a plurality of further input signals,assembles the transport stream and transmits compressed digital signalsto a transmitter 6 of the broadcast centre via linkage 7, which can ofcourse take a wide variety of forms including telecommunications links.The transmitter 6 transmits electromagnetic signals via uplink 8 towardsa satellite transponder 9, where they are electronically processed andbroadcast via notional downlink 10 to earth receiver 12, conventionallyin the form of a dish owned or rented by the end user. Other transportchannels for transmission of the data are of course possible, such asterrestrial broadcast, cable transmission, combined satellite/cablelinks, telephone networks etc.

The signals received by receiver 12 are transmitted to an integratedreceiver/decoder 13 owned or rented by the end user and connected to theend user's television set 14. The receiver/decoder 13 decodes thecompressed MPEG-2 signal into a television signal for the television set14. Although a separate receiver/decoder is shown in FIG. 1 a, thereceiver/decoder may also be part of an integrated digital television.As used herein, the term “receiver/decoder” includes a separatereceiver/decoder, such as a set-top box, and a television having areceiver/decoder integrated therewith.

In a multichannel system, the multiplexer 4 handles audio and videoinformation received from a number of parallel sources and interactswith the transmitter 6 to broadcast the information along acorresponding number of channels. In addition to audiovisualinformation, messages or applications or any other sort of digital datamay be introduced in some or all of these channels interlaced with thetransmitted digital audio and video information.

A conditional access system 15 is connected to the multiplexer 4 and thereceiver/decoder 13, and is located partly in the broadcast centre andpartly in the receiver/decoder. It enables the end user to accessdigital television broadcasts from one or more broadcast suppliers. Asmartcard, capable of deciphering messages relating to commercial offers(that is, one or several television programmes sold by the broadcastsupplier), can be inserted into the receiver/decoder 13. Using thereceiver/decoder 13 and smartcard, the end user may purchase commercialoffers in either a subscription mode or a pay-per-view mode. As usedherein, the term “smartcard” includes, but not exclusively so, anychip-based card device, or object of similar function and performance,possessing, for example, microprocessor and/or memory storage. Includedin this term are devices having alternative physical forms to a card,for example key-shaped devices such as are often used in TV decodersystems.

As mentioned above, programmes transmitted by the system are scrambledat the multiplexer 4, the conditions and encryption keys applied to agiven transmission being determined by the access control system 15.Transmission of scrambled data in this way is well known in the field ofpay TV systems. Typically, scrambled data is transmitted together with acontrol word for descrambling of the data, the control word itself beingencrypted by a so-called exploitation key and transmitted in encryptedform.

The scrambled data and encrypted control word are then received by thedecoder 13 having access to an equivalent to the exploitation key storedon a smart card inserted in the decoder to decrypt the encrypted controlword and thereafter descramble the transmitted data. A paid-upsubscriber will receive, for example, in a broadcast monthly ECM(Entitlement Control Message) the exploitation key necessary to decryptthe encrypted control word so as to permit viewing of the transmission.

Interactive System

An interactive system 16, also connected to the multiplexer 4 and thereceiver/decoder 13 and again located partly in the broadcast centre andpartly in the receiver/decoder, enables the end user to interact withvarious applications via a modemmed back channel 17. The modemmed backchannel may also be used for communications used in the conditionalaccess system 15.

FIG. 1 b shows the general architecture of the interactive televisionsystem 16 of the digital television system 1.

For example, the interactive system 16 allows an end user to buy itemsfrom on-screen catalogues, consult local news and weather maps on demandand play games through their television set.

The interactive system 16 comprises in overview four main elements:—

-   -   an authoring tool 4004 at the broadcast centre or elsewhere for        enabling a broadcast supplier to create, develop, debug and test        applications;    -   an application and data server 4006, at the broadcast centre,        connected to the authoring tool 4004 for enabling a broadcast        supplier to prepare, authenticate and format applications and        data for delivery to the multiplexer and scrambler 4 for        insertion into the MPEG-2 transport stream (typically the        private section thereof) to be broadcast to the end user;    -   a virtual machine including a run time engine (RTE) 4008, which        is an executable code installed in the receiver/decoder 13 owned        or rented by the end user for enabling an end user to receive,        authenticate, decompress, and load applications into the working        memory of the decoder 13 for execution. The engine 4008 also        runs resident, general-purpose applications. The engine 4008 is        independent of the hardware and operating system; and    -   a modemmed back channel 17 between the receiver/decoder 13 and        the application and data server 4006 to enable signals        instructing the server 4006 to insert data and applications into        the MPEG-2 transport stream at the request of the end user.

The interactive television system operates using “applications” whichcontrol the functions of the receiver/decoder and various devicescontained therein. Applications are represented in the engine 4008 as“resource files”. A “module” is a set of resource files and data. A“memory volume” of the receiver/decoder is a storage space for modules.Modules may be downloaded into the receiver/decoder 13 from the MPEG-2transport stream.

Receiver/Decoder

Referring to FIG. 2 a, the various elements of receiver/decoder 13 willnow be described in terms of functional blocks.

The receiver/decoder 13, which may be, for example, a digital set-topbox (DSTB), comprises a central processor 220 including associatedmemory elements and adapted to receive input data from a serialinterface 221, a parallel interface 222, a modem 223 (connected to themodem back channel 17 of FIG. 1 a), and switch contacts 224 on the frontpanel of the decoder.

The receiver/decoder is additionally adapted to receive inputs from aninfra-red remote control 225 via a control unit 226 and also possessestwo smartcard readers 227, 228 adapted to read bank and subscriptionsmartcards 242,240 respectively. The subscription smartcard reader 228engages with an inserted subscription card 240 and with a conditionalaccess unit 229 to supply the necessary control word to ademultiplexer/descrambler 230 to enable the encrypted broadcast signalto be descrambled. The decoder also includes a conventional tuner 231and demodulator 232 to receive and demodulate the satellite transmissionbefore being filtered and demultiplexed by the unit 230.

Processing of data within the receiver/decoder is generally handled bythe central processor 220. FIG. 2 b illustrates the softwarearchitecture of the central processor 220 of the receiver/decoder. Withreference to FIG. 2 b, the software architecture comprises aRun-Time-Engine 4008, a Device Manager 4068 and a plurality of Devices4062 and Device Drivers 4066 for running one or more applications 4056.

As used in this description, an application is preferably a piece ofcomputer code for controlling high level functions of preferably thereceiver/decoder 13. For example, when the end user positions the focusof remote control 225 on a button object seen on the screen of thetelevision set 14 and presses a validation key, the instruction sequenceassociated with the button is run.

An interactive application proposes menus and executes commands at therequest of the end user and provides data related to the purpose of theapplication. Applications may be either resident applications, that is,stored in the ROM (or FLASH or other non-volatile memory) of thereceiver/decoder 13, or broadcast and downloaded into the RAM or FLASHmemory of the receiver/decoder 13.

Applications are stored in memory locations in the receiver/decoder 13and represented as resource files. The resource files comprise graphicobject description unit files, variables block unit files, instructionsequence files, application files and data files, as described in moredetail in the above-mentioned patent specifications.

The receiver/decoder contains memory divided into a RAM volume, a FLASHvolume and a ROM volume, but this physical organization is distinct fromthe logical organization. The memory may further be divided into memoryvolumes associated with the various interfaces. From one point of view,the memory can be regarded as part of the hardware; from another pointof view, the memory can be regarded as supporting or containing thewhole of the system shown apart from the hardware.

Software Architecture

The central processor 220 can be regarded as centred on a run timeengine 4008 forming part of a virtual machine 4007. This is coupled toapplications on one side (the “high level” side), and, on the other side(the “low level” side), via various intermediate logical units discussedbelow, to the receiver/decoder hardware 4061, comprising the variousports as discussed above (that is, for example, the serial interface221, the parallel interface 222, modem 223, and control unit 226).

With specific reference to FIG. 2 b, various applications 4057 arecoupled to the virtual machine 4007; some of the more commonly usedapplications may be more or less permanently resident in the system, asindicated at 4057, while others will be downloaded into the system, egfrom the MPEG data stream or from other ports as required.

The virtual machine 4007 includes, in addition to the run time engine4008, some resident library functions 4006 which include a toolbox 4058.The library contains miscellaneous functions in C language used by theengine 4008. These include data manipulation such as compression,expansion or comparison of data structures, line drawing, etc. Thelibrary 4006 also includes information about firmware in thereceiver/decoder 13, such as hardware and software version numbers andavailable RAM space, and a function used when downloading a new device4062. Functions can be downloaded into the library, being stored inFLASH or RAM memory.

The run time engine 4008 is coupled to a device manager 4068 which iscoupled to a set of devices 4062 which are coupled to device drivers4060 which are in turn coupled to the ports or interfaces. In broadterms, a device driver can be regarded as defining a logical interface,so that two different device drivers may be coupled to a common physicalport. A device will normally be coupled to more than one device driver;if a device is coupled to a single device driver, the device willnormally be designed to incorporate the full functionality required forcommunication, so that the need for a separate device driver isobviated. Certain devices may communicate among themselves.

Each function of the receiver/decoder 13 is represented as a device 4062in the software architecture of the receiver/decoder 13. Devices can beeither local or remote. Local devices 4064 include smartcards, SCARTconnector signals, modems, serial and parallel interfaces, a MPEG videoand audio player and an MPEG section and table extractor. Remote devices4066, executed in a remote location, differ from local devices in that aport and procedure must be defined by the system authority or designer,rather than by a device and device driver provided and designed by thereceiver/decoder manufacturer.

The run time engine 4008 runs under the control of a microprocessor anda common application programming interface (API). They are installed inevery receiver/decoder 13 so that all receiver/decoders 13 are identicalfrom the application point of view.

The engine 4008 runs applications 4056 on the receiver/decoder 13. Itexecutes interactive applications 4056 and receives events from outsidethe receiver/decoder 13, displays graphics and text, calls devices forservices and uses functions of the library 4006 connected to the engine4008 for specific computation.

The run time engine 4008 is an executable code installed in eachreceiver/decoder 13, and includes an interpreter for interpreting andrunning applications. The engine 4008 is adaptable to any operatingsystem, including a single task operating system (such as MS-DOS). Theengine 4008 is based on process sequencer units (which take variousevents such as a key press, to carry out various actions), and containsits own scheduler to manage event queues from the different hardwareinterfaces. It also handles the display of graphics and text A processsequencer unit comprises a set of action-groups. Each event causes theprocess sequencer unit to move from its current action-group to anotheraction-group in dependence on the character of the event, and to executethe actions of the new action-group.

The engine 4008 comprises a code loader to load and downloadapplications 4056 into the receiver/decoder memory. Only the necessarycode is loaded into the RAM or FLASH memory, in order to ensure optimaluse. The downloaded data is verified by an authentication mechanism toprevent any modification of an application 4056 or the execution of anyunauthorized application. The engine 4008 further comprises adecompressor. As the application code (a form of intermediate code) iscompressed for space saving and fast downloading from the MPEG stream orvia a built-in receiver/decoder mode, the code must be decompressedbefore loading it into the RAM. The engine 4008 also comprises aninterpreter to interpret the application code to update various variablevalues and determine status changes, and an error checker.

Architecture of Receiver/Decoder

The receiver/decoder contains five software layers, organized so thatthe software can be implemented in any receiver/decoder and with anyoperating system. Referring to FIG. 2 c, the various software layers areApplication Layer 250, Application Programming Interface (API) layer252, Virtual Machine Layer 254, Device Layer 256 and SystemSoftware/Hardware Layer 258.

The Application Layer 250 encompasses applications that are eitherresident in or downloaded to the receiver/decoder. They may beinteractive applications used by customers, written in, for example,Java, HTML, MHEG-5 or other languages, or they may be applications usedby the receiver/decoder to run such applications. This layer is based ona set of open Application Programming Interfaces (APIs) provided by theVirtual Machine layer. This system allows applications to be downloadedto flash or RAM memory in the receiver/decoder on-the-fly or on demand.The application code can be transmitted in compressed or uncompressedformat using protocols such as Data Storage Media Command and Control(DSMCC), Network File Server (NFS) or other protocols.

Interactive applications are applications that the user interacts with,for example, to obtain products and services, such as electronic programguides, telebanking applications and games.

Various security features are provided for these downloaded applicationsand data, as follows:

-   -   Nothing can be downloaded to the receiver/decoder without first        having been authenticated for the intended network, which        prevents any unregistered software from being run in the        receiver/decoder. This means that any software running in the        receiver/decoder is recognized and has been fully tested.    -   A Security Manager limits access of applications to various        memory zones, thus assuring data integrity.    -   The system can interface with any conditional access system that        makes use of secure processors (for example, smart cards        inserted in the receiver/decoder).

The following resident applications are used to manage interactiveapplications:

-   -   Boot. The Boot application 260 is the first application launched        when the receiver/decoder is powered on. The Boot application        starts the different “Managers” in the Virtual Machine, the        first being the Application Manager 262.    -   Application Manager. The Application Manager 262 manages the        interactive applications that are run in the receiver/decoder,        that is, it starts, stops, suspends, resumes, handles events and        deals with communication between applications. It allows        multiple applications to run at once, and thus is involved in        the allocation of resources among them. This application is        completely transparent to the user.    -   SetUp. The purpose of the SetUp application 264 is to configure        the receiver/decoder, primarily the first time it is used. It        performs actions such as scanning for TV channels, setting the        date and time, establishing user preferences, and so on.        However, the SetUp application can be used at any time by the        user to change the receiver/decoder configuration.    -   Zapping. The Zapping application 268 is used to change channels        using the Program-up, Program-down and numeric keys. When        another form of zapping is used, for example, through a banner        (pilot) application, the Zapping application is stopped.    -   Callback. The Callback application is used to extract the values        of various parameters stored in the receiver/decoder memory and        return these values to the commercial operator via modemmed back        channel 17, or by other means.

The API layer 252 provides high-level utilities for interactiveapplication development. It includes several packages that make up thishigh-level API. The packages provide all the functionality necessary torun interactive applications. The packages are accessible by theapplications.

In a preferred embodiment the API is adapted to run applications writtenin the Java programming language. Furthermore, it can interpret HTML andother formats, such as MHEG-5. Besides these interpreters, it alsoincludes other packages and service modules that are detachable andextensible as requirements dictate.

The Virtual Machine layer 254 is composed of language interpreters andvarious modules and systems. It consists of everything necessary toreceive and execute interactive applications in the receiver/decoder,including the following:

-   -   Language Interpreters. Different interpreters can be installed        to conform to the type of applications to be read. These include        Java, HTML, MHEG-5 and others.    -   Service Information (SI) Engine. The SI Engine loads and        monitors common Digital Video Broadcasting (DVB) or Program        System Information Protocol (PSIP) tables and puts them into a        cache. It allows access to these tables by applications which        need the data contained in them.    -   Scheduler. This module allows for preemptive, multithreaded        scheduling with each thread having its own event queue.    -   Memory Manager. This module manages the access to memory. It        also automatically compresses data in memory when necessary and        performs automatic garbage collection.    -   Event Manager. This module allows events to be triggered        according to priority. It manages timer and event grabbing and        allows applications to send events to each other.    -   Dynamic Linker. This module allows the resolution of addresses        arising from native Java functions, loads native methods from a        Java class downloaded into RAM and resolves calls from        downloaded native codes towards ROM.    -   Downloader. This module uses automatic data loading from a        remote DSMCC carousel or through the NFS protocol, with        downloaded files accessed in the same way as resident ones.        Memory clear-up, compression and authentication are also        provided.    -   Class Manager. This module loads classes and resolves any class        referencing problems.    -   File System. This module is compact and optimized to manage a        hierarchical file system with multiple ROM, flash, RAM and DSMCC        volumes. Flash integrity is guaranteed against any incidents.    -   Security Manager. This module authenticates applications and        controls the access of applications to sensitive memory and        other zones of the set-top box.    -   Graphics System. This system is object-orientated and optimized.        It includes graphic window and object management as well as a        vectorial font engine with multi-language support.

Furthermore, the DAVIC resource notification model is supported so thatclient resources are efficiently managed.

The Device Interface layer 256 includes a Device Manager and devices.Devices are software modules which consist of the logical resourcesnecessary for management of external events and physical interfaces. TheDevice Layer manages communication channels between drivers andapplications and provides enhanced error exception checking. Someexamples of managed devices are: card readers, modems, network, PCMCIA(Personal Computer Memory Card International Association), LED displayand so on. Programmers do not have to deal with this layer directly,since the API layer controls the devices from above.

The System Software/Hardware layer 258 is provided by the manufacturerof the receiver/decoder. Because of the modularity of the system andbecause services supplied by the OS (such as event scheduling and memorymanagement) are part of the Virtual Machine, the higher layers are nottied to a particular real-time operating system (RTOS) or to aparticular processor.

Widget Sets

In a preferred embodiment, a widget set is provided for use inapplications to run in a graphical user interface (GUI). One particularapplication of such a widget set is to provide widgets in a GUI displayof a receiver/decoder for digital television. Each widget is implementedas an object-oriented module such that, for each widget, there is acorresponding widget class. Thus, any widget may be built up fromsimpler component widgets by inheriting or aggregating classes of otherwidgets.

FIG. 3 is a simplified diagram of the hierarchy of widgets within awidget set. In this embodiment, the widget set contains a set ofprimitive widget classes 410 including, amongst others, widow anddialogue box frames, a slider control, a push button, a check box, atext field, and a text editing box. At a next level of complexity, thereare classes 420 which combine several primitive widget classes or modifythe behaviour of a primitive widget. For example, a widget such as alist box may create editable list items from a text editing box classand allow a user to scroll through the list using a scroll bar derivedfrom a slider control class. At yet a higher level of complexity, thewidget set contains aggregate widgets 430 such as a file selectiondialogue box which contains push buttons, scrollable lists, text fieldsand text editing boxes, all of which are defined in other classes of thewidget set.

Each of the widget classes implements methods and event handlers tocontrol operation of the widget. The widget classes may also containmethods for drawing some parts of the widget. However, in order toprovide a particular appearance or “look” for the widget, the widgetclasses invoke drawing methods of a look object class with which thewidget class is associated. This will be described in further detailbelow.

Look Class Public Methods and API

In order that the look object classes and widget classes can interact,it is necessary for the look object classes to have a consistent set ofpublic methods that are guaranteed to be available for use by the widgetclass. In particular, the look object class must provide a standard API,which contains methods that the widget class can invoke in order to drawitself on a GUI display.

The API used by widgets is defined in a base class, from which all looksare derived. The API comprises the following elements:

1. General display methods

2. Particular display methods

3. Control of the creation and destructions of instances

4. Control of borders

5. Control of modifications

General display methods are those which are available to all widgetswhile particular display methods are particular to certain types ofwidget.

Looks are constructed using a hierarchical architecture. A new lookclass is created by inheriting the attributes, methods and defaultvalues of the class from which it is derived, and then adding newattributes, methods and default values, or overriding some or all ofthose inherited.

A look class is organised as a table containing pointers to publicmethods. A look class which is derived from another look class maytherefore redefine a method by changing the relevant pointer so that itpoints to another method. Typically, a look class only implements someof the available public methods.

In one implementation, public methods, known as dummy methods, areprovided, which do nothing other than return the call. If a method notimplemented by the look class is called by the widget, a dummy method iscalled. This is done in order to ensure error free functioning of methodcalls even when the method is in fact not implemented. A disadvantage ofcalling dummy methods is that time may be wasted in calling a methodwhich does nothing.

In another implementation, look classes are provided with validationmasks. A validation mask defines which methods can be called by the lookclass, so that methods which are not implemented are not called. Awidget can access the validation mask of a look class to optimise thedrawing of the widget. In this case, the widget is aware of methodswhich are not implemented, so the widget will avoid generating calls tosuch methods. In this way, it is possible to prevent time from beingwasted in calling dummy methods.

A look class may be derived from two or more other classes(multi-heritage). This can enable a look class to be created that is anunion of two or more other looks. As mentioned above, when a look classis created, it adopts the attributes, methods and default values of thelook class from which it is derived. In order to implementmulti-heritage, the look also contains one or more pointers to theadditional classes from which it derives attributes, methods and defaultvalues. The look can then access those attributes, methods and defaultvalues, without having to copy or create them itself.

In another embodiment, when a look class is created, it adopts theattributes, methods and default values of all of the look classes fromwhich it is derived.

The principle of multi-heritage is also useful in situations wherenon-standard widgets are designed, which may require the look toimplement non-standard methods. A pointer in the look can point to asecond look class which contains the non-standard methods that arerequired to display the widget.

It is important to ensure that the various look classes from which alook is derived do not conflict with each other. This can be done byensuring that the additional look classes only contain methods which arenot in the main look class from which the look is derived, or by givingan order of precedence to the various classes.

An example of the public methods of a look object class is set forthbelow.

/* Initialisation of instances */

MhwWgtLookInitDefault (MhwWgtLookclass* MhwWgtLookAtts*);

MhwWgtLookInitClass (Void);

MhwWgtLookResetDefault (MhwWgtLookclass*);

MhwWgtLookAttsGetDefault (MhwWgtLookClass*, MhwWgtLookAtts*);

MhwWgtLookAttsInit (MhwWgtLookAtts *);

/* Retrieve and set border dimensions */

MhwWgtLookAttsGetBorderwidthBottotm (MhwWgtLookAtts *, Card8*);

MhwWgtLookAttsGetBorderWidthLeft (MhwWgtLookAtts *, Card8*);

MhwWgtLookAttsGetBorderWidthRight (MhwWgtLookAtts *, Card8*);

MhwWgtLookAttsGetBorderWidthTop (MhwWgtLookAtts *, Card8*);

MhwWgtLookAttsSetBorderwidthBottom (MhwWgtLookAtts *, Card8);

MhwWgtLookAttsSetBorderWidthLeft (MhwWgtLookAtts *, Card8);

MhwWgtLookAttsSetBorderwidthRight (MhwWgtLookAtts *, Card8);

MhwWgtLookAttsSetBorderWidthTop (MhwWgtLookAtts *, Card8);

/* Retrieve and Set Colours*/

MhwWgtLookAttsGetColorBackground (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorBlack (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorDarkGray (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorForeground (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorHighlight (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorLightGray (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorMapAndVisual (MhwWgtLookAtts*, MhwWgtColorMapId*,MhwWgtVisual*);

MhwWgtLookAttsGetColorMiddleGray (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorTransparent (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorVeryLightGray (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsGetColorWhite (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsSetColorBackground (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsSetColorBlack (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsSetColorDarkGray (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsSetColorForeground (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsSetColorHighlight (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsSetColorLightGray (MhwWgtLookAtts*, MhwWgtColor*);

MhwWgtLookAttsSetColorMapAndVisual (MhwWgtLookAtts*, MhwWgtColorMapId,MhwWgtVisual);

MhwWgtLookAttsSetColorMiddleGray (MhwWgtLookAtts*, MhwWgtColor);

MhwWgtLookAttsSetColorTransparent (MhwWgtLookAtts*, MhwWgtColor);

MhwWgtLookAttsSetColorVeryLightGray (MhwWgtLookAtts*, MhwWgtColor);

MhwWgtLookAttsSetColorWhite (MhwWgtLookAtts*, MhwWgtColor);

/* Retrieve and Set Heritage Data */

MhwWgtLookAttsGetHeritageData1 (MhwWgtLookAtts*, Void**);

MhwWgtLookAttsSetHeritageData1 (MhwWgtLookAtts*, Void*);

/* Constructor */

MhwWgtLookNew (MhwWgtLookAtts*);

/* Destructor */

MhwWgtLookDelete (anObject)

/* Standard API */

MhwWgtLookDrawAnchor (anObject, aWidget, aX, aY, aW, aH, aText, aLength,anAscent, aState)

MhwWgtLookDrawBackground (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawCheckSymbol (anObject, aWidget, aX, aY, aW, aH, aState,aSymbol)

MhwWgtLookDrawChoiceSymbol (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawCross (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawCursor (anObject, aWidget, aX, aY, anAscent, aH)

MhwWgtLookDrawForeground (anObject, aWidget, ax1 aY1 aW, aH)

MhwWgtLookDrawFocus (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawHighlight (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawInset (anObject, aWidget1 aX, aY, aW, aH)

MhwWgtLookDrawIterm (anObject, aWidget, aX, aY, aW, aH, aText,aTextLength, anAscent, aState)

MhwWgtLookDrawOutset (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawRelief (anObject, aWidget, aX, aY, aW, aH, aRelief)

MhwWgtLookDrawSelectedBG (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawSlidArrow (anObject, aWidget, aX, aY, aW, aH, aDirection)

MhwWgtLookDrawSlidLift (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookDrawString (anObject, aWidget, aX, aY, aText, aLength,anAscent)

MhwWgtLookGetBorderWidth (anObject, aBorder)

MhwWgtLookGetClassId (anObject)

MhwWgtLookGetClassName (anObject)

MhwWgtLookGetItemBorderWidth (anObject)

MhwWgtLookGetMethodMask (anObject)

MhwWgtLookGetPreferredSizeArrow (anObject)

MhwWgtLookGetPreferredSizeCheck (anObject)

MhwWgtLookGetPreferredSizeChoice (anObject)

MhwWgtLookGetPreferredSizeCross (anObject)

MhwWgtLookGetUpdateCounter (anObject)

MhwWgtLookIsInstanceOf (anObject, aClassId)

MhwWgtLookReDrawItem (anObject, aWidget, aX1 aY, aW, aH, aText, aLength,anAscent, aState)

MhwWgtLookRef (anObject)

MhwWgtLookSetBorderWidth (anObject, aBorder, aWidth)

MhwWgtLockUnDrawCross (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookUnDrawCursor (anObject, aWidget, aX, aY anAscent, aH)

MhwWgtLookunDrawFocus (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookunDrawHighlight (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookunDrawRelief (anObject, aWidget, aX, aY, aW, aH)

MhwWgtLookunRef (anObject)

MhwWgtLookGetBackground (anObject)

MhwWgtLookGetColorBlack (anObject)

MhwWgtLookGetColorDarkGray (anObject)

MhwWgtLookGetColorHighlight (anObject)

MhwWgtLookGetColorLightGray (anObject)

MhwWgtLookGetColorMap (anObject)

MhwWgtLookGetColorMiddleGray (anObject)

MhwWgtLookGetColorTransparent (anObject)

MhwWgtLookGetColorVeryLightGray (anObject)

MhwWgtLookGetColorWhite (anObject)

MhwWgtLookGetColorForeground (anObject)

MhwWgtLookGetColorHeritageData1 (anObject)

MhwWgtLookGetColorHeritageLink1 (anObject)

Creating and Displaying a Widget

When an application requires a widget to appear on the display of a GUI,the first task it must perform is to construct an instance of the widgetclass. During creation of the widget instance, a look class instancebecomes associated with the widget class instance. The particular lookis chosen as follows:

-   1. If a look class instance is passed by the application to the    constructor, then use it.-   2. Otherwise, use the default look specified for the class of widget    being created, if there is one.-   3. Otherwise, use the default look specified for the widget context,    if there is one.-   4. Otherwise, use the default look for the widget set.

Once the widget class has been instantiated, the application can invokean appropriate one of its public methods to display it.

The widget class also preferably provides a public method that can becalled with a pointer to a look class instance, and that look classinstance then becomes associated with the widget class instance. Thiscauses the appearance of the widget to change in accordance with thenewly associated look class instance. It should be understood that“association” is, in reality, nothing more than setting the value of afield within the widget class instance. To associate the widget with adifferent look class can, in the simplest of embodiments, be done simplyby making an assignment to the field. (However, see the comments belowrelating to memory management and the method MhwWgtXxxSetLook.)Moreover, many widget class instances may be associated with one lookclass instance. This is illustrated diagrammatically in FIG. 5.

When a widget class method is called to draw the widget on a GUIdisplay, it builds the image of the widget in the following order:

1. The background of the widget (for example, a background colour or animage).

2. Background overlay (for example, a logo)

3. Foreground of the widget

4. Foreground overlay (for example, a logo)

5. The widget border.

6. Highlighting

7. Input focus.

For a given widget, certain parts may be absent. The presence or absenceof a part of the widget depends on the following criteria.

-   1. Hard coding. Some of the parts are not defined for certain    classes of widget.-   2. Optional parts. For example, the focus, the relief and the    highlight may be inhibited at will by means of a public attribute of    the widget.-   3. Definition of the look. A look can omit one or more of the parts.

In a typical example, the following steps are carried out.

Firstly the background of the widget is drawn by the widget class methoditself, for example, by painting a background colour, a backgroundpattern or an image. The background overlay is then drawn by invokingthe public method of the associated look instanceMhwWgtLookDrawBackground specifying appropriate arguments for theheight, width and position of the widget on the display. The appearanceof the background is thus modified by the look, for example, byoverlaying a logo.

The widget class method must then build up the foreground of the widget;that is to say, it creates the visual objects that actually aremanipulated by a user or display information when the widget is in use.For example, the widget might implement a check box, in which case itinvokes the look class method MhwWgtLookDrawCheckSymbol. The look maythen modify the foreground, for example by overlaying a logo.

The border region of the widget is then drawn, as will be describedbelow.

If the widget class determines that one of the objects within the widgethas input focus, it invokes the look class method MhwWgtLookDrawFocus toindicate this in the displayed widget. Similarly, if part of the widgetis to be highlighted, the widget class invokes the look class methodMhwWgtLookDrawHighlight.

Widget Border Management

One specific example of the way in which the look controls theappearance of the widget on a GUI display is in the management ofborders. The appearance of a widget with borders in its most generalform on a GUI display is shown in FIG. 4. The widget 500 occupies arectangular area in the display of a GUI. The area occupied by thewidget includes two regions: an inner operative region 510 surrounded bya border region.

The border region typically does not contribute to the function of thewidget (although it may, in some cases, by used by a user to move and/orre-size the widget). Therefore, there is considerable scope forvariation of the appearance of the border region in accordance with auser's wishes. For example, the colour, width, background pattern canall be selected to appeal to a user or to provide a consistentappearance. Therefore, responsibility for drawing the border is given tothe look class.

The look maintains four dimensions to specify the width of the border.These specify the distance from the left, right, top and bottom of theoperative region 510 to the edge of the widget. These dimensions areindicated respectively at L, R, T, and B in FIG. 4. Values for thesedimensions are specified in the default look. An application may definea class derived from the default look class in which the values areoverridden to create a look that creates a widget with a border ofnon-standard width. An application (for example, a look manager) canalso change the values at run time by invoking the look methodsMhwWgtLookAttsSetBorderwidthBottom, MhwWgtLookAttsSetBorderWidthLeft,MhwWgtLookAttsSetBorderwidthRight, or MhwWgtLookAttaSetBorderWidthTop.

Within the look class there is code that controls the detailed layout ofa border according to values passed to the look class by the widgetclass.

Widget Colour Management

A look also includes a definition of colours, so that any widgetinstance which is associated with a particular look instance will usethe colours defined in that look instance. In one embodiment, a lookdefines the following colours:

-   -   black    -   dark gray    -   middle gray    -   light gray    -   very light gray    -   white    -   transparent    -   highlight colour

The colour definitions in the look are used when drawing a widget. Forexample, if a black line is to be drawn when displaying a widget, thecolour which has been defined as “black” will be used. For example, ifthe look is to have a red hue, then “black” may be defined to be darkred, and “white” may be defined to be light pink, with various shades ofred being defined in between. In this example, a drawing operation whichwould normally draw a black line will instead draw a dark red line, andso on.

In addition, the look defines a colour map which sets the actual colourvalues which are to be used when displaying any particular colour on thedisplay of a GUI.

Creating a Modified Widget

Suppose that the default look method MhwWgtLookDrawCheckSymbol draws arectangular box which is either empty or which contains a small ticksymbol depending on its state, and that this defines the look of anormal check box in a GUI. Now suppose that another widget is requiredin which either a tick or a cross is displayed. The appearance isentirely controlled by the look class, so only the look class need bealtered. Moreover, a new look class to implement this behaviour can bederived from the existing look class, and provide only one methodMhwWgtLookDrawCheckSymbol to override the method of the same name in thebase look class. Moreover, when the method MhwWgtLookDrawCheckSymbol isinvoked with the argument aState set to true, the methodMhwWgtLookDrawCheckSymbol of the base class can be called to draw atick. New code need be written only to handle the case where a cross isto be drawn. Thus, a new widget can be created with a minimum ofprogramming effort.

It should be understood that this procedure does not alter theappearance of the original check box widget; this widget uses the baselook class which has not been amended. In order to effect a change tothe appearance of the original check box widgets in an application, themethod MhwWgtLookDrawCheckSymbol in the base look class must be amended.All check box widgets derived from that class will then change theirappearance following the next occasion (at compile time, or run time, asthe case may be) upon which the look class is linked with theapplication.

The widget class will, in principle, co-operate to create a widget withany class having an appropriate set of public methods and properties asa look class. However, there is advantage in deriving all look classesfrom as small as possible a number of common base classes, and ideallyjust one base class. Those familiar with object-oriented programmingwill understand that this minimises the use of memory and otherresources by the look classes. A derived class has a pointer to its baseclass so that it can access method code and static data of the baseclass without duplication of such code or data in memory.

Version Control

It may be that some widget instances have a very long life. For example,the root window of a window manager, a taskbar widget in a workstationdisplay, and so forth. In such cases, there is a strong possibility thatthe look classes might be updated during the life of the widget. Thewidget class must be caused to re-draw itself when this happens.

One a way to achieve this is to give each look class an update counterwhich is exported as a public property or is accessible though a publicmethod. When a widget class is instantiated, the widget class instancequeries the update counter of the associated look, and stores the valueof the update counter in memory local to the widget class instance. Ifthe instance of the look class is subsequently updated, the widget classinstance can detect this change by comparing the value that is stored inits local memory with the value of the update counter in the look classinstance. If the look class instance has been updated, the widget canthen redraw itself using the methods of the look class.

Construction and Destruction of Look Class Instances

In general, there will be fewer instances of each look class than ofeach widget class. In some cases, there may be just one instance of alook base class referred to by all widget class instances in anapplication. There may also be instances of derived look classesreferred to by some of the widget class instances of an application.However, a widget class cannot assume that there will always be a lookclass instance in existence at the time that the widget class is beinginstantiated; the widget instance might be the first to requireassociation with a particular look class.

Therefore, it is proposed that during instantiation of each widgetclass, the widget class constructor invokes the associated look classconstructor MhwWgtLookNew. If no instance of the look class exists, thena new instance is created. A value of 1 is then stored in a referencecounter held in the local memory of the look class instance. If aninstance of the look class already exists, the look class constructorreturns a pointer to it, and increments the reference counter.

During destruction of each widget class instance, the destructor of thewidget class invokes the destructor MhwWgtLookDelete for the associatedlook class instance. The destructor MhwWgtLookDelete decrements thereference counter. If the counter remains greater than zero, thedestructor simply returns. However, if the destructor reaches zero, thenno widget class instances (other that the one undergoing destruction)are associated with that look class instance, in which case the lookclass destructor proceeds to remove the look class instance from memory.

The widget class method MhwWgtXxxSetLook can be called to change thelook with which a particular widget class instance is associated. Withinthis method, a call is first made to the destructor of the outgoing lookclass instance, and a call is then made to the reference function of thenew look class to obtain a pointer to a class instance. This ensuresthat the reference counters of the look classes are properly updated.

There must also provision for a new instance of a look class to becreated even if an instance already exists. This allows an applicationto have more than one instance of any given look class, and to setdifferent attributes in the different instances. For example, there maybe two instances of the same look class identical in all respects otherthan one has all attributes remaining in accordance with their defaults,and the other having different values assigned to one or more of itsattributes (border width, colour, and so forth).

Look Managers

As will be understood, the system of look classes and instances allowsvery detailed control over the overall look of an application. Forinstance, just one attribute of any look class can be changed to effecta minor change to the look of an application. Accordingly, a lookmanager application may be provided to enable a user to alter theseattributes as required.

Such an application typically includes a GUI display including widgetsembodying the invention in order that the user can immediately see theeffect of changing the attributes of the look upon the appearance of thewidget.

Web Browser

The internet navigator interface will now be described with reference tothe accompanying drawings.

FIG. 6 a shows a screenshot of the main screen navigator display of anInternet browser.

The main screen shows a vertical chain 1100 which includes the main menuwhich includes various buttons as a linked list. The buttons are linkedby link elements of the chain. The buttons shown in the chain 1100 ofFIG. 6 a include the RELOAD/STOP button 1110, the PREVIOUS button 1120,NEXT button 1130, HISTORY button 1140, BOOKMARK button 1150, SETTINGSbutton 1160 and the QUIT button 1170.

The main menu chain 1100 is arranged to be superimposed on thehyper-text markup language (HTML) document to be displayed on the screen1101. In FIG. 6 a, no HTML document is displayed and the screen 1101 isblank apart from the main menu chain 1100.

The web browser includes several preferences which can be set by theuser. The browser includes a facility for setting several user profiles.

The user has a controller with which he can navigate between objects onthe screen 1101, highlight objects and select objects. In the presentexample, the controller used is a television remote control 1180. Thenumber keys 1181 are used to enter data; the cursor keypad 1182 is usedto navigate around the screen. The cursor keypad 1182 includes an UP key1183, a DOWN key 1184, a LEFT key 1185 and a RIGHT key 1187. The cursorkeypad 1182 also incudes a SELECT key 1186 which is used for selectingobjects on the screen.

The UP key 1183 and the DOWN key 1184 are used to move a focus, in thisexample a highlight up and down the chain 1100 to selectively highlightthe buttons 1110, 1120, 1130, 1140, 1150, 1160 and 1170. When a buttonis highlighted, it can be selected using the select key 1186.

When an HTML page is displayed, any button of the remote control callsthe chain 1100 (toolbar). The chain 1100 can also be turned on and offby the user. In one settings option the chain 1100 automatically ishidden when a new HTML page is displayed, the user calling up the chain1100 when he wants to move to another HTML page.

FIG. 7 shows the screen of FIG. 6 a having an HTML document open.Information about the open document is given in a text box 1112 linkedin the chain to the RELOAD/STOP button 1110. It will be seen that thechain links 1114 between the buttons indicate visually to the user thathe can move between the buttons in the direction of the links.

FIG. 6 a shows the RELOAD/STOP button highlighted (the highlightedRELOAD/STOP icon is white on a dark background rather than dark on awhite background as in FIG. 7 where it is not highlighted). The HTMLdocument can be reloaded by pressing the select key 1186 when theRELOAD/STOP button is highlighted.

The user moves the highlight down the chain 1100 using the DOWN key1184. In FIG. 7, the PREVIOUS button 1120 is now highlighted. FIG. 8shows how, when the highlight is on the PREVIOUS button 1120 a “tooltip”comprising a text box 1122 appears on the screen. In the presentexample, the tooltip appears as soon as the relevant icon ishighlighted. The preferences could be set so that the tooltip appearsafter a delay when the button is highlighted. The text box 1122 includesthe word “previous” to indicate the function of the PREVIOUS button1120. By activating the PREVIOUS button, by pressing the SELECT key1186, the browser moves to the previous page viewed.

In FIG. 9, the highlighting is moved down to the NEXT button 1130 and,after a short time, a tooltip comprising a text box 1132 including theword “next” appears to assist the user.

In FIG. 10, the HISTORY button 1140 is highlighted and its associatedtooltip 1142 appears with the word “history”. The HISTORY button 1140has more than one function and so, activating the button by pressing theSELECT key 1186 on the control keypad causes a sub-chain 1144 to appeargiving further options relating to the history function. The sub-chain1144 is shown in FIG. 11. The sub-chain 1144 includes additional buttonsincluding a VIEW button 1146 and an ADD button 1148. The user movesalong the sub-chain 1144 using the RIGHT and LEFT keys 1187, 1185. Inthe screen display of FIG. 11, the VIEW button is highlighted and atooltip 1147 appears to tell the user that the button highlighted isVIEW. It will be noted that the tooltips attached to the main chain 1100appeared on the right hand side of the chain 1100; the tooltips for thesubchain appear above the sub-chain.

The size of the box for the tooltip is matched to the length of the wordor words to be displayed. Where different language preferences can beset, the size of the box for the tooltip is preferably matched to thelength of the word in the language selected.

FIG. 12 shows the display obtained when the VIEW button is selected. AVIEW HISTORY window 1141 appears on the screen having a heading 1143(here the French language option has been selected for the heading) andshowing details 1145 of previous pages viewed by the user. The user mayscroll up and down the text and highlight one of the details 1145 usingthe SELECT key 1186. The LEFT and RIGHT keys are used to highlight theOK or CANCEL keys 1149, 1149′.

FIG. 13 shows the ADD button 1148 highlighted and its associatedtooltip. The ADD button 1148 is used to add the presently displayed pageto the history list 1145.

FIG. 14 shows the BOOKMARK button 1150 highlighted and its associatedtooltip 1151. In FIG. 15, the BOOKMARK button 1150 has been selected andthe bookmark sub-chain 1152 is shown including the tooltip 1151, theVIEW, ADD, DELETE and EDIT buttons, 1153, 1154, 1155, 1156. In FIG. 15,the VIEW button 1153 is highlighted and its tooltip shown. The VIEWbutton 1153 is selected and the VIEW window 1157 is shown (see FIG. 16).(It will be seen that, for clarity, the bookmark sub-chain 1152 is notshown when the view window 1157 is on the screen.) The VIEW window 1157includes a heading, and a scrollable text box listing bookmarks. As forthe VIEW HISTORY window, the window also includes OK and CANCEL keys.The cursor keypad 1182 is used to navigate about the window and toselect a bookmark, if desired.

In FIG. 17, the ADD button 1154 is highlighted and its tooltip isdisplayed. If the ADD button is selected, the ADD window is displayed(see FIG. 18). The ADD window 1158 includes two boxes for text entry toenter the URL of the bookmark and its title. Data is entered into thewindow using the number keys 1181 (for example using the on-screenkeyboard described herein). The window also includes OK and CANCEL keysas described above. The user navigates between the text entry boxes andthe OK and CANCEL keys using the cursors 1182.

FIG. 19 shows the DELETE button 1155 highlighted and its tooltip. Byselecting the DELETE button 1155, bookmarks may be deleted.

FIG. 20 shows the EDIT button 1156 highlighted and its tooltip. Byselecting the EDIT button 1156, bookmarks may be edited.

FIG. 21 shows an alternate form of the bookmark sub-chain 1152 in whichthe bookmark tooltip 1151 is not shown. This can save space on thescreen, in particular if the sub-chain is long. The appearance of thetooltips is an option which can be selected by the user.

FIG. 22 shows the SETTINGS button 1160 highlighted, and its tooltip1161. When SETTINGS is selected, the authentication window 1165 isdisplayed (see FIG. 22) prompting the user to identify himself and togive the user password before the settings can be altered. Theauthentication window 1165 includes two text entry boxes for the entryof the username and password using the number keys 1181 and OK andCANCEL buttons. Once the correct username and password have been enteredinto the authentication window 1165 and the OK button selected, thesettings sub-chain 1162 is displayed, see FIG. 24.

The settings sub-chain 1162 includes the MODEM button 1163 and theBROWSER button 1164. FIG. 24 shows the MODEM button 1163 highlighted andits associated tooltip. By selecting the MODEM button 1163, the settingsof the modem may be changed. FIG. 25 shows the BROWSER button 1164highlighted and its associated tooltip. When the BROWSER button 1164 isselected, the browser window 1166 is displayed, see FIG. 26. Again, theuser navigates around the objects in the window using the cursor keys1182. The objects in the browser window include a COLOUR drop-down list1167. By highlighting the list head and selecting it using the cursorkeys 1182, the items of the list appear and the user can move up anddown the list and select a new browser colour using the cursors.Similarly, the text language of the browser can be changed using thedrop-down list 1168. By moving the highlight to the tooltip select 1169and pressing the select button 1186, the tooltips can be turned on andoff. The window includes, as before, OK and CANCEL buttons.

FIG. 27 shows the QUIT button 1170 highlighted and its associatedtooltip 1171. If the QUIT button 1170 is selected, the quit sub-chain1172 appears (FIG. 28). In FIG. 28, the CONFIRM button 1173 ishighlighted and has its tooltip displayed. If the user wishes to quitthe web browser, he selects the CONFIRM button 1173. If the user wantsto cancel the quit selection, he selects the CANCEL button 1174 shownhighlighted in FIG. 29 with its tooltip.

Alternative designs of the main menu chain 1100 may be used, whereby theshape of the individual buttons and the texture can been changedpreferably without changing the overall shape of the chains. The colourmay also be changed. These changes can be made available as options inthe settings menu, the shape and texture of the chain being changed as awhole to give a coherent design (skin) for the browser.

For example, the buttons might have square, circular, diamond or othershapes, with a texture preferably designed to give a three-dimensionalappearance. The appearance of the links between the buttons may bedesigned to match the appearance of the buttons, or alternatively tocomplement it. The appearance of the links may also be chosen so as togive the appearance of structural solidity, to enhance the user'sperception that the buttons are meaningfully interlinked.

The arc shape of the chain shown in FIGS. 6–30 is chosen by thedeveloper, and is preferably not alterable by the user. Otherconfigurations of the button chain and sub-chains are possible, such asa straight chain or a semi-circular chain. In other embodiments, thebutton order and configuration of the button chain and sub-chains may bemodified by the user.

The receiver/decoder provides internet navigation and email-readingcapabilities.

The graphical studio for modelling a navigator is now discussed.

The graphical studio for modelling a navigator is an ensemble orcollection of elementary graphical objects. Each graphical object is thepictorial representation on a television screen of one of the functionsof the navigator. Each function of the navigator can be represented by agraphical object, or by a sequence of images of a graphical object (ananimated image), or a collection of graphical objects (for example, animage in the background of the screen or an image in the background of adialog box to which other graphical objects can be attached). There aretwo internal formats for images: MPEG2 and PIXMAP-GRL.

The PNG format is used for elementary graphical objects representing the“navigation system” functionality: load, connect, previous document,next document, exit, etc.

To imprint a non-rectangular image on the graphical plane, it isnecessary to use a clipping mask which defines the visible (significant)zones. This mask must be provided by the designer in the form of abitmap: this mask is not calculated by the program owing to performanceconstraints.

The two stages for adding a clipping mask are first displaying an imageand then, in the graphical plane, filling in a rectangle of the samedimension and position of the image with the transparency colour whileapplying the clipping mask to render visible the useful part of theimage.

The PIXMAP-GRL image format is used for graphical objects representingthe navigator resources or the user interface: vertical scrollbar,tables, simple choice, multiple choice, etc.

The PIXMAP type objects are of variable dimension (each graphical objector model is decomposed into simple elementary objects) and colourable(changing colour).

The PIXMAP-GRL image format may be obtained by converting any othergraphical formats (such as BMP, JPEG, GIF, PNG, etc.) using well-knownmethods.

The decomposition of a graphical object into graphical elements iseffected according to a matrix (e.g. 3×3, 4×4 or 1×4) which depends onthe type of object being displayed.

The palette contains 256 colours. This palette is applied to graphicalobjects of type PIXMAP and PNG. In a palette, there are two parts. Thefirst part consists of 26 colours which are reserved to facilitate thedisplay and the design of the application. The second part consists of230 non-modifiable colours which are available for use by applications.

The maximum size of the screen is 720 pixels wide by 576 high. Toguarantee the visibility of the screen on every low-end television set,it is necessary to restrict the size to 592 pixels wide and 480 high. Toexploit high-end television sets, the user will have the option toadjust the size of the screen. For an internet navigator, sites have ingeneral designed their pages 600 pixels wide and 400 high.

The generic attributes of a graphical object are now discussed indetail.

A graphical object (according to what it represents) has a precise size.The exact size is defined by the designer and serves as a guide for thedisplay.

Each graphical object is resizeable. According to the type of graphicalobject, it is possible to resize the width and/or height. The method ofresizing of a PIXMAP-GRL graphical object follows the recommendations ofthe decomposition of a graphical object. The method of drawing variablesize graphical objects is discussed further later on.

The image of the graphical object on the screen is represented by amulticoloured shape; the background image should have a range of coloursif possible (fluid, the effect of modelling clay).

The image of the graphical object does not have to be drawn according toits position (coordinates), or according to the order of the followingor preceding object on the screen: the notion of a floating position ofthe object. Each object is by definition independent of the otherobjects (except for a background image).

The text is printed by the program according to the chosen language.This implies that no image should contain text. The design of an objectis left in the hands of the designer. The general look can follow aparticular theme (e.g. Startrek, 007, the Simpsons).

The aspect of focus can be represented by several means: a rectangularfocus on the graphical object; a focus highlighting (with anothercolour) the background of the graphical object, or a focus colouring inthe shape of the graphical object.

The normal state (without focus, active, not depressed) is the basic oneof the graphical object.

The inhibited state of a graphical object can be represented by severalmeans: the shape of the object in grey (or vignetted); the overlaying ofa distinctive prohibitive sign on the graphical object in question;setting the background of the object to monocolour, or making the objectinvisible.

The depressed state of a graphical object is the graphicalrepresentation of an object having the focus following a click on it butbefore the button is released. This representation can be an inversedisplay of the object or it can be the same as the focussed state.

With regard to the flip-flop (head to tail) display effect, an image oricon may comprise two visual aspects: one representing the text (thereverse, or ‘tails’ side of a Euro coin, for example), the otherrepresenting a symbol (the face, or ‘heads’ side). This visual effect isanimated by a program running on a timer, a timer is started at thedisplay of a first icon, and as soon as the timer reaches apredetermined value, the change of icon takes place: either a secondicon is displayed, or a sequence of icons showing a progressive changeis displayed.

The decomposition of a graphical object of PIXMAP-GRL type is nowdescribed, with reference to FIGS. 31 to 38. These figures show examplesof the elementary graphical objects used in the matrix decompositionmethod (1201–1209, 1211–1219, etc.), and the corresponding graphicalobject formed when the elementary objects are combined in theappropriate fashion (1210, 1220, etc.). The figures have been enlargedapproximately by a factor of four.

To be able to resize a graphical object (increase or decrease), eachgraphical object (a design created by the graphic artist) is split intothe form of a matrix of graphical elements like the pieces of a puzzle.Each element is then referenced according to the four cardinal cornersand the centre (north, south, east, west, centre, north-east,north-west, south-east, south-west, centre of the centre). The width andheight of the matrix depends on the type of object.

Certain graphical elements (pieces of the puzzle) are printed only once(the corners). To make the object wider or taller, certain elements areprinted in a repetitive fashion (n times the width or height of theelement, respectively).

Graphical objects which are formed by, or form part of, the matrixdecomposition (or tiling) method are now listed. These graphical objectsare drawn in the HTML document area.

-   -   Button with/without text in the active state (1210): 3×3 matrix        (1201–1209); size of elements: 4 pixels wide and high; elements        to resize the width: north-centre (1202), centre (1205),        south-centre (1208); elements to resize the height: west-centre        (1204), centre (1205), east-centre (1206).    -   Button with/without text in the active, depressed state (1220):        3×3 matrix (1211–1219); size of elements: 4 pixels wide and        high; elements to resize the width: north-centre (1212), centre        (1215), south-centre (1218); elements to resize the height:        west-centre (1214), centre (1215), east-centre (1216).    -   Button with/without text in the inactive, greyed state (1230):        3×3 matrix (1221–1229); size of elements: 4 pixels wide and        high; elements to resize the width: north-centre (1222), centre        (1225), south-centre (1228); elements to resize the height:        west-centre (1224), centre (1225), east-centre (1226).    -   ‘Check box’, shown with/without focus, and crossed/uncrossed        (FIG. 34): 1×1 matrix; size of elements: 16 pixels wide and        high; elements to resize the width: none; elements to resize the        height: none.    -   List of options, for single or multiple selection (1252, 1253,        1254): 3×3 matrix (1241–1249); size of elements: 4 pixels wide        and high; elements to resize the width: north-centre (1242),        centre (1245), south-centre (1248); elements to resize the        height: west-centre (1244), centre (1245), east-centre (1246);        can comprise an up (1250) and/or down indicator (1251);        position: x,y origin+width and height of the up indicator.    -   Up indicator (1250): 1×1 matrix; size of elements: 16 pixels        wide and 8 pixels high; elements to resize the width: none;        elements to resize the height: none; position: y origin, centred        on the width    -   Down indicator (1251): 1×1 matrix; size of elements: 16 pixels        wide and 8 pixels high; elements to resize the width: none;        elements to resize the height: none; position: y origin+height        of up indicator+height of list, centred on the width.    -   Table (for drawing forms) (1260): 3×3 matrix (1270); size of        elements: 2 pixels wide and high; elements to resize the width:        north-centre, centre, south-centre; elements to resize the        height: west-centre, centre, east-centre; can comprise a cell.    -   Cell (for drawing an entry in a form) (1280): 3×3 matrix (1290);        size of elements: 2 pixels wide and high; elements to resize the        width: north-centre, centre, south-centre; elements to resize        the height: west-centre, centre, east-centre; can comprise text        or an image; position: x,y origin+thickness of the table border.    -   Text with frame (TextArea) (1300): 3×3 matrix (1310); size of        elements: 2 pixels wide and high; elements to resize the width:        north-centre, centre, south-centre; elements to resize the        height: west-centre, centre, east-centre; can comprise text.    -   Frame (1320): 3×3 matrix (325); size of elements: 4 pixels wide        and high; elements to resize the width: north-centre, centre,        south-centre; elements to resize the height: west-centre,        centre, east-centre    -   Vertical scrollbar (1330): 1×3 matrix; size of elements: 8        pixels wide and high; elements to resize the width: none;        elements to resize the height: centre; attached to the frame        (depending on the position of the frame object); comprises the        indicator graphical object of the index relative to the height.    -   Horizontal scrollbar (1340): 3×1 matrix; size of elements: 8        pixels wide and high; elements to resize the width: centre;        elements to resize the height: none; attached to the frame        (depending on the position of the frame object); comprises the        indicator graphical object of the index relative to the width.    -   Horizontal line: 1×1 matrix; size of elements: 4 pixels wide and        high.    -   Vertical line: 1×1 matrix; size of elements: 4 pixels wide and        high.

A summary of all of the graphical objects in the web browser interfaceand their associated functions is now given.

What follows is a non-exhaustive list of the graphical objects which arenecessary for the construction of a navigator model in the decoder. Thetable given here lists the objects element-by-element and the list ofobjects composed of several graphical elements.

Elementary graphical object Functionality Type Comments BTN_ConnecterConnect/disconnect Clickable PNG Initiates the modem connection themodem line image with the defined profile information BTN_DéconnecterConnect/disconnect Clickable PNG Disconnects the modem the modem lineimage BTN_Information_Profil Access to the Clickable PNG Displays adialog box for authentication image configuring the subscriberinformation for the profile: login, password and connection profiletelephone number BTN_Information_Serveur Rapid access to the ClickablePNG Displays a dialog box for proxy server image configuring theparameters of information the proxy servers BTN_Configuration_(—) Rapidaccess to the Clickable PNG Displays a dialog box for navigateurnavigator options image configuring the navigator optionsBTN_Accés_Email Rapid access to the Clickable PNG Starts the emailclient email application image BTN_Document_Précédent Previous pageClickable PNG Displays the immediately image preceding HTML pageBTN_Document_Suivant Next page Clickable PNG Displays the immediatelyimage following HTML page BTN_Stop_Chargement Stop the current ClickablePNG Stops the current document from document loading image loadingBTN_Annuaire Rapid access to Clickable PNG Displays a dialog boxcontaining bookmarks image the bookmark list BTN_Quitter Leaves theClickable PNG Leaves the application application and image returns to TVBTN_Saisie_Adresse Rapid access to the Clickable PNG Opens the dialogbox from selection of a link image which one can access a site address(URL) or from which one selects an established URL IMG_Logo_NavigateurLogo Clickable PNG Circular sequence of images to image display thecurrent loading activity IMG_Logo_Opérateur Logo Clickable PNG imageIMG_Diode Status or activity Non-clickable Coloured diodes (LEDs): red,indicator PNG image green, blue, black, yellow BTN_Fléche_haut Move upone row Clickable and Clickable images indicating: non-clickabledepressed state, non-depressed PNG image state and inhibited stateNon-clickable images indicating: inhibited and normal statusBTN_Fléche_bas Move down one Clickable and Clickable images indicating:row non-clickable depressed state, non-depressed PNG image state andinhibited state Non-clickable images indicating: inhibited and normalstatus BTN_Fléche_droite Move cursor Clickable and Clickable imagesindicating: forward non-clickable depressed state, non-depressed PNGimage state and inhibited state Non-clickable images indicating:inhibited and normal status BTN_Fleche_gauche Move cursor Clickable and3 clickable images: depressed backward non-clickable state,non-depressed state and PNG image inhibited state 2 non-clickableimages: inhibited and normal status BTN_Page_haut Move cursor upClickable and 3 clickable images: depressed several rows (half anon-clickable state, non-depressed state and page or previous PNG imageinhibited state page) 2 non-clickable images: inhibited and normalstatus BTN_Page_bas Move cursor down Clickable and 3 clickable images:depressed several rows (half a non-clickable state, non-depressed stateand page or following PNG image inhibited state page) 2 non-clickableimages: inhibited and normal status BTN_Frame_Suivante Go to next frameClickable PNG 3 clickable images: depressed image state, non-depressedstate and inhibited state. This image is visible if there is a framefollowing; otherwise the image is not displayed to avoid overloading thescreen BTN_Frame_Précédente Go to previous Clickable PNG 3 clickableimages: depressed frame image state, non-depressed state and inhibitedstate. This image is visible if there is a frame following; otherwisethe image is not displayed to avoid overloading the screenBTN_Choix_Croix Indicator of Clickable and Like a box for insertion of awhether an option non-editable cross. Multiple choice possible. within alist is PNG image Hence there are 2 images: checked or not checked andnon-checked BTN_Choix_Simple Indicator of Clickable and Like a box forinsertion of a whether an option non-editable cross. Only one choicefrom a within a list is PNG image list. Hence there are 2 images:checked or not checked and non-checked BTN_Ok Validates a Clickable andGeneric validation image question or non-editable (without text). To beused in a information PNG image dialog box. . . BTN_Annuler Deletes aquestion Clickable and Generic deletion image (without or informationnon-editable text). To be used in a dialog PNG image box. . . BTN_OuiPositive answer to a Clickable and Generic validation image questionnon-editable (without text). To be used in a PNG image dialog box. . .BTN_Non Negative answer to Clickable and Generic negation image aquestion non-editable (without text). To be used in a PNG image dialogbox. . . IMG_Curseur_Normal_(—) Pointer/graphics Normal graphics Like anarrow with a hotspot Souris cursor cursor indicator imageIMG_Curseur_Attente_(—) Pointer in busy Busy indicator Like an egg timeror Souris mode chronometer IMG_Curseur_Texte Position of the Indicatorgraphics cursor in a text during access IMG_Statusline Display of a textin Background Image without text. The text will one row of 4/5 of imagefor be displayed in truncated the size of the displaying non- format.The text has no more screen editable text than 40 charactersIMG_Indéfinie Generic display of Clickable and Image representing animage in an image not yet non-clickable an HTML document which hasloaded image not yet been loaded into the memory, or whose loading wasinterrupted BDG_Login_Password Generic dialog box Screen Backgroundimage delimiting an for displaying or background area of informationaltext, login entering the login image with field or password field. Thisand the password graphic border dialog box is required to access foraccessing a a secure site. The program secure site masks the passwordBDG_Information_Profil Generic dialog box Screen Background imagedelimiting an for displaying or background area of informational text,login entering the login, image with field, password field or passwordand graphic border telephone number field. This telephone number dialogbox is required before of a distance access dialling the access server.The server. program masks the password, and confirmation of the passwordwill be requested. BDG_Confirmation_(—) For confirming the Dialog boxBackground image delimiting an Password entry of a having a area ofinformational text and a password. background password field. Thisdialog box image with is required when the user graphic border modifiesor enters a new password. The program masks the passwordIMG_Telecommande_(—) Filigree (outline of Outline The outline of theremote filigrane the keys) of the control is overlaid on the imageremote control for of the virtual keyboard to make advanced entry thekeys of the remote control using the virtual correspond visually to thelayout keyboard of keys of the virtual keyboard. Rapid access by visualmemory and not by documentary memory. The outline of the remote controlkeys does not consist of any letters or symbols. BKG_Clavier_virtuelVirtual keyboard Background The virtual keyboard is for advanced entryimage of a represented on the screen like using a remote keyboard thatof a PC but without control displaying letters or figures on the keys.Putting letters on each key is handled by the program: this allows thedefinition of a generic international language keyboard (azerty, qwertyor others). The outline image of the remote control is overlaid on thekeyboard and follows the focus: this achieves the aim of showingvisually that pressing a remote control button corresponds to a keypress on the keyboard without having to memorize the translation inadvance. The ESCape key dismisses the virtual keyboard. Certain keysserve as function keys: “http://www”, “.fr”, “.com”, “.org”, etc., andothers have certain functions: “Enter”, “Backspace”, “Del”, etc.BKG_Toolbar_Navigation Displayed in the Background toolbar backgroundimage BKG_Toolbar_Systeme_(—) Displayed in the Background Configurationtoolbar background image BKG_Annuaire Displayed in the Backgroundbackground of the image bookmark dialog box BKG_Information_ProfilDisplayed in the Background background of the image subscriber profileconfiguration dialog box BKG_Information_Serveur Displayed in thebackground of the proxy server configuration dialog box

The following table describes the different elementary graphical objectswhich form a graphic object which can have a variable size in thegraphical representation. The juxtaposition of elementary objects tomake a complex object is effected by the program (reconstituting thepuzzle). These objects are of PIXMAP format.

Elementary graphical object Functionality Type CommentsTBL_Vertical_Gauche To represent the Image To draw a border on a tableof border of a variable variable size. This object size table representsa vertical stretch of the left side of the border TBL_Vertical_Droite Torepresent the Image To draw a border on a table of border of a tablevariable size. This object represents a vertical stretch of the rightside of the border TBL_Horizontal_Haut To represent the Image To draw aborder on a table of border of a table variable size. This objectrepresents a horizontal stretch of the top side of the borderTBL_Horizontal_Bas To represent the Image To draw a border on a table ofborder of a table variable size. This object represents a horizontalstretch of the bottom side of the border TBL_Angle_Haut_(—) To representthe Image To draw the top left corner of a Gauche corner of the bordertable border. of a table TBL_Angle_Haut_(—) To represent the Image Todraw the top right corner of a Droite corner of the border table border.of a table TBL_Angle_Bas_(—) To represent the Image To draw the bottomleft corner Gauche corner of the border of a table border. of a tableTBL_Angle_Bas_Droite To represent the Image To draw the bottom rightcorner corner of the border of a table border. of a tableCEL_Vertical_Gauche To represent the Image To draw the border of a cell.border of a cell This object represents a vertical stretch of the leftside of the border. A cell is one compartment in a table. . . Thethickness of a cell border should be smaller than that of the tableCEL_Vertical_Droite To represent the Image To draw the border of a cell.border of a cell This object represents a vertical stretch of the rightside of the border. CEL_Horizontal_Haut To represent the Image To drawthe border of a cell. border of a cell This object represents ahorizontal stretch of the top side of the border. CEL_Horizontal_Bas Torepresent the Image To draw the border of a cell. border of a cell Thisobject represents a horizontal stretch of the bottom side of the border.CEL_Image To represent the Generic image Generic image representing theborder of a non- placement of a non-loaded loaded image in a image in acell cell BDG_Vertical_Gauche To represent the Generic image To draw theborder of a border of a dialog variable-size dialog box. This box objectrepresents a vertical stretch of the left side of the border.BDG_Vertical_Droite To represent the Generic image To draw the border ofa border of a dialog variable-size dialog box. This box objectrepresents a vertical stretch of the right side of the border.BDG_Horizontal_Haut To represent the Generic image To draw the border ofa border of a dialog variable-size dialog box. This box objectrepresents a horizontal stretch of the top side of the border.BDG_Horizontal_Bas To represent the Generic image To draw the border ofa border of a dialog variable-size dialog box. This box objectrepresents a horizontal stretch of the bottom side of the border.BDG_Angle_Haut_(—) To represent the Generic image To draw the top leftcorner of Gauche border of a dialog the border of a variable size boxdialog box. BDG_Angle_Haut_Droite To represent the Generic image To drawthe top right corner of border of a dialog the border of a variable sizebox dialog box. BDG_Angle_Bas_Gauche To represent the Generic image Todraw the bottom left corner border of a dialog of the border of avariable size box dialog box. BDG_Angle_Bas_Droite To represent theGeneric image To draw the bottom right corner border of a dialog of theborder of a variable size box dialog box. LST_Vertical_Gauche Torepresent the Image To draw the border of a variable border of avertical size vertical list. This object list of selectable represents avertical stretch of options the left side of the border.LST_Vertical_Droite To represent the Image To draw the border of avariable border of a vertical size vertical list. This object list ofselectable represents a vertical stretch of options the right side ofthe border. LST_Bas_Gauche To represent the Image To draw the border ofa variable border of a vertical size vertical list. This object optionsrepresents a horizontal stretch of the top side of the border.LST_Bas_Droite To represent the Image To draw the border of a variableborder of a vertical size vertical list. This object list of selectablerepresents a horizontal stretch of options the bottom side of theborder. LST_Angle_Haut_Gauche To represent the Image To draw the topleft corner of corner of the border the border of a variable size of avariable size vertical list. vertical list of selectable optionsLST_Angle_Haut_Droite To represent the Image To draw the top rightcorner of corner of the border the border of a variable size of avariable size vertical list. vertical list of selectable optionsLST_Angle_Bas_Gauche To represent the Image To draw the bottom leftcorner corner of the border of the border of a variable size of avariable size vertical list. vertical list of selectable optionsLST_Angle_Bas_Droite To represent the Image To draw the bottom rightcorner corner of the border of the border of a variable size of avariable size vertical list. vertical list of selectable optionsASC_Haut To represent a Clickable and To draw the top end of a verticalvertical scroll bar non-clickable scroll bar (‘elevator’) (‘elevator’)image ASC_Bas To represent a Clickable and To draw the bottom end of avertical scroll bar non-clickable vertical scroll bar image ASC_Cage Torepresent a Clickable and To draw one step (‘floor’) of a verticalscroll bar non-clickable vertical scroll bar image ASC_Ascenseur Torepresent a Clickable and To indicate the position of the verticalscroll bar non-clickable vertical scroll bar image SCR_Gauche Torepresent a Clickable and To draw the left end of a horizontal scrollbar non-clickable horizontal scroll bar of a image window, text area,frame, etc. SCR_Droite To represent a Clickable and To draw the rightend of a horizontal scroll bar non-clickable horizontal scroll bar of aimage window, text area, frame, etc. SCR_Cage To represent a Clickableand To draw one compartment (step) horizontal scroll bar non-clickableof a horizontal scroll bar of a image window, text area, frame, etc.SCR_Position To represent a Clickable and To indicate the position ofthe horizontal scroll bar non-clickable cursor in the horizontal scrollimage bar of a window, text area, frame, etc. IMG_Texte_Gauche Torepresent a line Non-clickable This is the image at the left side oftext to display image of the non-editable displayed text. The chosensize must match that of the chosen character set IMG_Texte_Droite Torepresent a line Non-clickable This is the image at the right of text todisplay image side of the non-editable displayed text. The chosen sizemust match that of the chosen character set IMG_Texte_Caractere Torepresent a line Non-clickable This is the background image on of textto display image which a non-editable character is printed. The chosensize must match that of the chosen character set, IMG_Edition_Gauche Torepresent a line Editable and This is the image at the left side of textto edit clickable image of an editable or selectable text zone. Thechosen size must match that of the chosen character set.IMG_Edition_Droite To represent a line Editable and This is the image atthe right of text to edit clickable image side of an editable orselectable text zone. The chosen size must match that of the chosencharacter set. IMG_Edition_Caractere To represent a line Editable andThis is the background image on of text to edit clickable image which acharacter of an editable or selectable text zone is printed. The chosensize must match that of the chosen character set. IMG_Multi_Edition_(—)To represent the Editable and This is the image at the left side Gaucheediting of multi-line clickable image of an editable or selectable texttext zone. The chosen size must match that of the chosen character set.IMG_Multi_Edition_(—) To represent the Editable and This is the image atthe right Droite editing of multi-line clickable image side of aneditable or selectable text text zone. The chosen size must match thatof the chosen character set. IMG_Multi_Edition_(—) To represent theEditable and This is the background image on Caractere editing ofmulti-line clickable image which a character of an editable text orselectable text zone is printed. The chosen size must match that of thechosen character set.Navigator Functions

Graphical Function Description Activated by Objects Comments Connect/Initiate the BTN_Connecter Start the modem disconnect modemBTN_Déconnecter connection if it is off-line, connection if theconnection profile with the information is filled in, if defined a URLis clicked. profile/ disconnect the modem Configure- Displays aBTN_Information_(—) BDG_Information_(—) Enter, modify, validate, modifythe dialog box to Profil Profil store in flash memory the authen-configure the login, password and tification subscriber telephone numberof the information profile: access server of the login, Cancel theaccess connection password, profile telephone Confirm the Request theAfter a password BDG_Confir- Enter, validate, cancel entry of a passwordto has been changed mation_Password Each entered character is passwordbe re-entered replaced by a masking character (asterisk) when printedCompare the entry with the modified password Print or enter RequestFollowing an BDG_Login_(—) Enter, validate, cancel, the login andauthen- attempt to access Password sending information to the passwordto tification a secure site site access a from the Each character of thesecure site remote site password is replaced by a masking character(asterisk) when printed Managing a Virtual When the focusBKG_Clavier_(—) The virtual keyboard is virtual keyboard for is on aneditable Virtuel represented on the screen like keyboard advance objectIMG_Tele- that of a PC but without entry with a commande_filigranedisplaying letters or figures on remote the keys. Putting letters oncontrol each key is handled by the program: this allows the definitionof a generic international language keyboard (azerty, qwerty or others).The outline image of the remote control is overlaid on the keyboard andfollows the focus: this achieves the aim of showing visually thatpressing a remote control button corresponds to a key press on thekeyboard without having to memorize the translation in advance. TheESCape key dismisses the virtual keyboard. Certain keys serve asfunction keys: “http://www”,“.fr”,“.com”, “.org”, etc., and others havecertain functions: “Enter”, “Backspace”,“Del”, etc.

The Java API for the web browser is now described.

There follows the list of the JAVA packages which are used at the levelof the navigator application in the decoder. This list is divided intotwo parts: the AWT (Abstract Window Toolkit) classes of the JDK 1.1 andthe JAVA interface classes of the different services written in native Ccode.

Classes Methods java.awt.Choice Add(String) GetItemCount( )GetSelectedIndex( ) Remove(String) SetSelectedIndex(int)java.awt.Component AddKeyListener(KeyListener)AddFocusListener(FocusListener) AddMouseListener(MouseListener)Contains(int,int) enableEvents(long) getLocation( ) getSize( )setBackground(Color) setBackground(ImageMask) setBackground(int)setLocation(int) setSize(int,int) java.awt.Graphics drawImage getSizesetLocation java.awt.Image createImage(String) getHeight( ) getWidth( )java.awt.ImageMask extends java. setMask(bitmap) awt.Image java.awt.ListList(int) add(String) getItem(num) getItemCount( ) getSelectedItem( )remove(String) replace( ) setMultipleMode(boolean) java.awt.PanelsetLayout(layout) java.awt.Point java.awt.Toolkit loadLut(String)getDefaultToolkit( ) java.awt.TextFieldaddActionListener(ActionListener) setEchoChar(char) setSecretMode( )java.awt.Window setModal(boolean) java.awt.event.FocusEventjava.awt.event.FocusListener void focusGained(FocusEvent) (interface)void focusLost(FocusEvent) java.awt.event.KeyEventjava.awt.event.KeyListener(interface) void keyPressed(KeyEvent) voidkeyReleased(KeyEvent) void keyTyped(KeyEvent) java.awt.event.MouseEventjava.awt.event.MouseListener void mouseClicked(MouseEvent) (interface)void mouseEntered(MouseEvent) void mouseExited(MouseEvent) voidmousePressed(MouseEvent) void mouseReleased(MouseEvent)

The navigator package, called the browser package, groups togetherdifferent packages: the browser.drawer package, which offers servicesallowing an HTML document to be fetched, and navigation within thedocument browser; and the mediawebtv package, which allows theestablishment of an internet connection with the users authentification.

The structure of the browser.drawer.MhwBookmark class is now described.

A bookmark list is associated with a user. There is no hierarchy withinthe bookmark list.

Constructor: MhwBookmark(subscriberId): opens an existing bookmark list

Constructor: MhwBookmark(subscriberId): creates a new bookmark list

deleteBookmark( ): destroys a bookmark list

add (URL, name): adds an entry

remove (itemNumber): deletes an entry

modify (itemNumber, URL, name): modifies an existing entry

getList ( ): returns a list of the entries in the bookmark list (nohierarchy)

getItemCount ( ): returns the number of entries in the bookmark list

is Full ( ): boolean—list is full?

is Empty ( ): boolean—list is empty?

setHomePage (itemNumber)

getHomePage ( ): itemNumber

goToURL (sessionNumber): loads the document corresponding to theselected entry

In the event of failure, an error message is returned by the methodsadd( ), remove( ), modify( ), getList( ), setHomePage( ) (or an event ifthe occurrence is asynchronous).

The browser.drawer.MhwHistory class permits the navigation from onedocument to another within a list of previously displayed documents.There is no hierarchy in the history list. The details of the class arenow given.

Constructor: MhwHistory (sessionNumber)

getList ( ): returns the history list (no hierarchy)

getCurrent ( ): gets the current URL

setCurrent(indexNumber): change the current URL

getNext ( ): gets the URL of the next entry

getPrevious ( ): gets the URL of the previous entry

getItemCount ( ): returns the number of entries in the history

addEventsRegister ( ): subscribes to the error events of the historylist

removeEventsRegister ( )

In the event of failure, an error message is returned by the methodsgetList( ), getNext( ), getPrevious( ), setCurrent( ) (or an event ifthe occurrence is asynchronous).

The events are: addEventsRegister(sessionNumber): [subscribes to thehistory list error events]; and removeEventsRegister(sessionNumber)[unsubscribes].

The browser.drawer.MhwDocument class allows the loading and displayingof an HTML document in the decoder. The details of the class are nowgiven.

Constructor: MhwDocument (sessionNumber)

freeze ( ): halts the display of the current document (loading of thedocument continues)

unfreeze ( ): restarts the display of the current document

is Pending ( ): whether the document is currently loading

stop ( ): halts the loading of the current document

reload ( ): reloads the document

getDocumentInfo ( ): returns the title and the URL of the document

addStatusRegister ( ): subscribes to information on the state and end ofloading

goToURL (url): loads a web page

submit (login, password, URL): submits authentication for loading a webpage

getStatisticsDocument ( ): returns the number of requests in progressand the URL of the document currently being loaded

The browser.mediawebtv.MhwConnection class groups together the userconnection and authentification functionality. The details of the classare now given.

-   Constructor: MhwConnection (subscriberId)-   start ( ): requests connection-   stop ( ): requests disconnection-   cancel ( ): cancels the connection-   setAuthentificationType (type): sets the mode of authentication to    the CANAL+mode (msd/password) or by login/password-   getAttributes ( ): returns the connection attributes-   setAttributes (attributes): modifies the connection attributes-   setPassword (password): modifies the password-   getPassword (password): gets the password-   setAutoCheckPassword (bAutoCheck): sets whether the password is to    be verified automatically with the confirmation password-   getAutoCheckPassword (bAutoCheck): reads whether the password is to    be verified automatically with the confirmation password-   getIPClient (ipaddress, netmask): reads the selected IP and netmask    pair-   setIPClient (ipaddress, netmask): modifies the IP and netmask pair-   getDNS (dns1, dns2): reads the primary and secondary DNS addresses-   setDNS (dns1, dns2): modifies the primary and secondary DNS    addresses-   getURLConfigServer (url): reads the address of the configuration    server-   setURLConfigServer (url): modifies the address of the configuration    server-   getQueryCommand (queryCmd, typeOfQuery): reads by type the request    to be sent to the configuration server-   setQueryCommand (queryCmd, typeOfQuery): modifies the request by    type-   queryAcquisitions (tableAcquisitions, typeOfAcquisition,    NumberOfAcquisitions): reads the list of acquisitions-   startAcquisition (acquisitionId): starts an acquisition (data/video)-   stopAcquisition (acquisitionId): stops an acquisition (data/video)-   addStatusRegister ( ): subscription to be informed of the connection    status

The events are: loss of connection; current connection; establishedconnection; connection confirmation request; connection error, modemstatus: on/off; initialisation in progress; dialling in progress; errorbut modem is on; server status: invalid port, invalid URL; login error:unknown login; and invalid password.

-   removeStatusRegister ( ): unsubscribes to the network connection    status-   is Connected subscriberId( ): returns boolean giving the modem    connected/disconnected status-   is Pending ( ): returns boolean for modem currently establishing    connection-   getExtendedProviderUrl (providerUrl): reads the provider currently    subscribed to-   setExtendedProviderUrl (providerUrl): modifies the provider    currently subscribed to

The browser.mediawebtv.MhwConfiguration class manages the profile ofeach user and his or her preferences. The details of the class are nowgiven.

Constructor: MhwConfiguration( )

readProfile(subscriberId): read the profile

writeProfile(subscriberId, profile): write the profile

readDefaultProfile( ): read the default profile

writeDefaultProfile(profile): modify the default profile

getUserCount( ): number of users

newUser(profile): identifying for a new user

getLastConnect( ): the last connected user

The maximum number of profiles is currently fixed at 5, but this doesnot represent a strict limit; higher numbers of profiles may be storedif need be.

In the case of failure, an error message is returned by theWriteProfile( ) and writeDefaultProfile( ) methods (or an event if theoccurrence is asynchronous)

The browser.mediawebtv.MhwMultiSession class allows a navigator sessionto be selected. A session is an instance of the navigator which wasautomatically initiated by another instance. When the navigator starts,a session is created following the establishment of an authenticatedconnection. The details of the class are now given.

Constructor: MhwMultiSession

getCurrentSessionNumber( )

setCurrentSessionNumber(int number)

getPreviousSession( )

addSession( ): returns the number of the session created

removeSession(int numSession)

The navigator model for the decoder is now described in more detail,with reference to FIGS. 6 a and 7–30.

The model presented here is a simple example of a navigator, and gives ageneral idea of the principal functionality. It gives total freedom atthe level of graphical representation. The only important features arethe zones or screens within which functions of the same type are groupedand the general user interface.

The navigator employs all of the available graphics (MPEG, PIXMAP) ofthe graphical studio. The screens of this model are organised in treeform and each one groups together a collection of essential functions.Each function or option in a screen is accessed by moving a focus withthe aid of arrow buttons (on the remote control) or by using a keypadwith a cursor/pointer. The selection of an action is achieved by acontroller click or by a predefined button (e.g. “OK”).

In the absence of a physical keyboard, to enter text with the remotecontrol, it is necessary to provide a virtual keyboard. This is achievedby moving the focus with a possibility of tapping quickly, by mappingthe buttons of the remote control onto the virtual keyboard; in otherwords the image of the buttons on the remote control is visible (intraced form) in outline, or slightly opaque, on the picture of thevirtual keyboard. The virtual keyboard is discussed in more depth laterin this document.

FIG. 30 shows the top-level chain of navigator function buttons (1410),with a portion of a web page visible beneath (1411).

The main navigator screen is now described, with specific reference toFIG. 30.

The navigator functions are grouped in several layers. The main screendisplays a vertical bar (main menu) (1410) which is composed of a seriesof buttons: Reload/Stop (1401), previous page (1402), next page (1403),history of recently visited sites, bookmarks, connect/disconnect,configuration, exit navigator (1408).

The navigator GUI (main screen) (1410) is displayed when a function keyis pressed (either on the remote control or on the keyboard). When theGUI is visible on the TV screen, the HTML document (1411) (which the GUIcovers over) continues to be loaded into memory, but the refresh of thedocument is suspended so as not to affect the display performance of theGUI. The HTML document is redisplayed when the navigator GUI isdismissed. This restriction will be lifted if the performances areeventually satisfactory, thereby allowing the simultaneous display ofthe HTML document and the GUI.

The GUI is dismissed from the TV screen by pressing a function key (onthe remote control or the keyboard), or by clicking outside the GUIbutton zones. The display of the HTML document currently being loaded orstored in the cache memory is then started or recommenced.

A button is effectively a rectangular or square zone (for example, 32×32pixels). When the graphics cursor enters a zone, that zone (window)receives the focus (cf. the EnterNotify(WindowId) function).

If the button graphic is a tyre, for example, it has to be detectedwhether the actual position of the graphics cursor effectively coversthe pixels of the tyre. To this end, it is necessary to find the valueof the pixel at the hotspot of the mouse pointer in the clipping mask ofthe button (by calculation of the relative position, getpixel( ) in theclipping mask, then testing the pixel value). This detection methodallows the test to be improved for whether or not a click was effectedbefore starting the function of the button.

When the mouse pointer leaves the button's rectangular or square zone,the zone loses the focus (cf. LeaveNotify(WindowId)).

The descriptive button summaries are now described in more detail.

When the mouse pointer or the rectangular focus coincides with a buttonrepresenting a function, a short phrase (tooltip) is displayed eitherhorizontally or vertically, describing the function of that button. Whenthe button is selected, either by a mouse click or by a function key, alist of buttons appears containing sub-menu options. The system of shortdescriptive phrases (tooltips) is also used for the sub-menu buttons.

Navigation of the menu options is achieved with the arrow keys either onthe remote control or on the keyboard. The last button on the mainscreen to have had the focus is remembered for the next time the mainscreen is displayed.

The virtual keyboard is now discussed in more detail, with reference toFIGS. 42–45.

FIG. 42 shows schematically how the currently visible virtual keyboard(1501) maps onto the underlying ‘grid’ of virtual keyboards (1501,1506).

FIG. 43 shows a typical mapping of characters to keys on a virtualkeyboard.

FIG. 44 shows the images used for the virtual keyboard, with the first(1545) and second (1546) number block having the focus respectively(also showing two different types of remote control 1542 and 1543).

FIG. 45 shows a typical virtual keyboard layout with typical dimensionssuperimposed.

Firstly, the virtual keyboard is conceived as an tool which isindependent of the application in which it is used. This, it can be usedwithin the “WebBrowser” application and equally within the “Mail”application. Moreover, its ‘look’ is completely independent of the‘look’ of the application concerned.

The virtual keyboard is displayed from the moment that the user, notpossessing a physical keyboard or a remote control with keyboard,selects an editable area of the screen. The focus is positioned at theend of the text in the editable area. Pressing “OK” (on the remotecontrol or virtual keyboard) or “Cancel” (on the virtual keyboard)dismisses it.

The virtual keyboard which is visible on the screen (1501) is composedof three blocks of ten keys (representing three number blocks of theremote control) side by side (1502, 1503, 1504). The user can pass thefocus (1505) from one block to another using the arrow keys on theremote control. After a block is selected, pressing a button on thenumber block of the remote control enters the corresponding characterprinted on the virtual keyboard.

The user can also use the up and down arrow keys. This brings the samevirtual keyboard on the screen but with different characters on the keys(1506). Thus, flipping between a set of 5 virtual keyboards, one candisplay all of the characters on the keyboard of a western computer.There is also the possibility of adding other keyboards as the needarises.

With reference to FIG. 44, to allow an immediate association to be madebetween the number block of the remote control and the focus on thevirtual keyboard, a superimposed image of the remote control indicatesthe focus (1542, 1543). Thus the user can easily visualise that only onepart of the keyboard has the focus, and that the rest of the characterscan be reached by moving the focus with the arrow keys. The keyboard isdesigned with the latter points in mind.

The virtual keyboard solution takes up little screen height, and allowsfor easy extension of the number of characters available. By default, itis the virtual keyboard with the miniature alphabet which is displayed.

Certain buttons have important special functions:—

-   -   “OK” on the remote control, for validing the current choice (if        the field only has one line, the ¶ character (1521) also        validates, or may alternatively be chosen to have no effect at        all; otherwise, it corresponds only to a carriage return).    -   “Cancel” (1522) on the virtual keyboard, to exit the tool        without validating (the modifications made after opening the        keyboard will be lost).    -   “Back Space” (1523) on the virtual keyboard, which erases the        last character entered.    -   The up, down, left and right arrow keys, to move within the        editing area.    -   “Tab” (1520) on the virtual keyboard, which inserts a        configurable number of spaces in one go (four by default).

The keyboard is always in ‘insert’ mode.

An example of a keyboard is given in FIG. 44, and is discussed furtherbelow.

With the 5 keyboards (5×3) shown in FIG. 43, and the two fonts installedfor the WebBrowser application (Arialweb and Courier), all of thecharacters of a traditional keyboard can be covered. The dimensions ofthe keyboard on screen are 272 pixels wide by 184 pixels high.

The virtual keyboard and the functional connections with regard to itsuse in the various applications are developed within the“canalplus.virtualkbd” package.

The classes comprised within the package include “MhwVirtualKbd” (thevirtual keyboard graphical description and behavioural class),“MhwVkTextField” (the class derived from ‘java.awt.TextField’ whichallows a virtual keyboard defined within the global application sharingthe TextField to control events) and “MhwTextArea” (a class inheritedfrom the ‘java.awt.TextArea’ which allows a virtual keyboard definedwithin the global application using the TextArea class to controlevents).

The MhwVirtualKbd class is now described in more detail.

The constructor of the “MhwVirtualKbd” class is defined as ‘private’.Thus only one unique virtual keyboard can be constructed, when the mainapplication which may need to use it is started (in the absence of aphysical keyboard, for example). The aim is therefore to present akeyboard configured especially for the current application, and whichappears when the user enters a text field (single- or multi-line).

When the keyboard is created, the four main (static) variables which canbe configured will have been set:—

-   -   parent: container, ‘parent’ of the virtual keyboard, which must        itself exist at the time the keyboard is created. It is set        using the “setParent” method which returns a        ‘NullPointerException’ if the ‘parent’ passed in the argument is        ‘null’.    -   descriptive file: ASCII file which describes the keyboard, both        in terms of the graphics behind the images, which concerns the        various ‘keyboards’ obtained when the virtual keyboard is used,        and the labels printed on the keys. The characters are specified        by their unicode code. The name of the descriptive file can be        set using the “setScreensFile” method.    -   number of screens: number of ‘number blocks’ initialised and        used by the virtual keyboard. This number, set using the        “setScreensNumber”, corresponds to the number of keyboards, the        characteristics of which are read in the descriptive file        detailed above.    -   initial coordinates: these are the coordinates of the top-left        corner of the background image of the keyboard in the parent        container (described above). This is set using the        “setCoordInit” method.

Once the keyboard is created, it can be decided whether or not to use itby using the “getInstance” method, which finds the keyboard of thecurrent application, if it exists (if the virtual keyboard of theapplication does not yet exist, and if the application uses it, the“getInstance” method creates one, using for it the variables [the fourpreviously described] which one would have set).

Event management is now described.

According to the preceding descriptions, the virtual keyboard functions,once displayed, solely by interpreting the events sent to it by: thenumber block, the “OK” button, and the four arrow direction keys on theremote control. These buttons will have specific roles for the keyboardin use.

The “OK” button has an important role, because it allows the user to dotwo things: ‘return’ to the text field to enter information, and thendisplay and start the operation of the virtual keyboard; and ‘leave’ thetext field, saving the changes.

Arrow Keys

The ‘right’ and ‘left’ arrows allow the image of the remote control(indicating the number block which has the ‘focus’) to be moved on thethree number blocks which are represented on the virtual keyboard. Thekeys of the number block on the remote control are thus ‘bound’,depending on the ‘keyboard’ having the focus, to the display of variouscharacters.

In the most common case, ‘tapping’ on of these buttons when the virtualkeyboard is active causes the automatic insertion of the character shownon that key, in the current text field at the position indicated by thecursor.

Of the characters, six can be considered as ‘special’ characters, and donot directly cause the character displayed on the key to be displayed inthe text field:

BackSpace: ‘<’ (1523): when the button on the remote controlcorresponding to this character is pressed, the character immediately tothe left of the cursor position in the current text field is erased.

Tab: ‘>>’ (1520): when the button on the remote control corresponding tothis character is pressed, a configurable number of spaces (‘ ’), 4 bydefault, is inserted at the current cursor position.

Enter: ‘¶’ (1521): when the button on the remote control correspondingto this character is pressed, a ‘line feed’ is inserted at the cursorposition. In fact, if the current text field is an instance of the‘MhwVkTextField’ class, i.e. one which only has one editable line,tapping this button will either have no effect or cause validation ofthe field. If, on the contrary, this text field is an instance of the‘MhwVkTextArea’ class, it consists of several editable lines and thischaracter causes a ‘line feed’ (if the cursor is positioned on the lasteditable line, tapping this button will have no effect).

Cancel: ‘¢’ (1522): when the button on the remote control correspondingto this character is pressed, all of the modifications made to thecurrent text field subsequent to the opening of the virtual keyboard areundone. In other words, its content is returned to the value it hadbefore the modifications were made, and the virtual keyboard is‘exited’.

Left arrow: when the button on the remote control corresponding to thischaracter is pressed, the cursor in the current text field is moved oneplace to the left. If the cursor is already in the ‘zero’ position (nofurther movement to the left is possible), this button has no effect.Right arrow: when the button on the remote control corresponding to thischaracter is pressed, the cursor in the current text field is moved oneplace to the right. If the cursor is already positioned after the lastcharacter in the text field (and cannot move any further right), thisbutton has no effect.

Up arrow: when the button on the remote control corresponding to thischaracter is pressed, the cursor in the current text field is moved oneplace upwards. If the cursor is already in the first line of the textfield (or if the current text field only has one line: MhwVkTextField),this button has no effect.

Down arrow: when the button on the remote control corresponding to thischaracter is pressed, the cursor in the current text field is moved oneplace downwards. If the cursor is already in the last line of the textfield (or if the current text field only has one line: MhwVkTextField),this button has no effect.

The “findLocation” method determines the placement of the virtualkeyboard on the screen, seeking to minimise the “cropped” surface.

The MhwVkTextField class is simply a specialisation of the “TextField”class in the “java.awt” package. It additionally manages a boolean valuewhich specifies the use (or not) of the virtual keyboard.

The constructors are exactly the same as those of the “TextField” classin the “java.awt” package, with a simple additional argument: a booleanspecifying the use of the virtual keyboard.

If the boolean is “true”, a ‘base’ instance of the “TextField” class iscreated, and a virtual keyboard listener, available within the currentapplication, is also added at the same time, using the “addKeyListener”method. If not, a ‘normal’ TextField is created.

When the TextField has the focus, if the user presses ‘OK’ and theboolean specifies the use of the virtual keyboard, the virtual keyboardis displayed and gains the focus. It manages all of the events and isable to fill the text field. If the user presses ‘OK’ again, its text isvalidated, and the keyboard returns the focus. If the use of the virtualkeyboard is not envisaged (boolean=false), the “TextField” has the same‘behaviour’ as a standard TextField in “java.awt”.

The MhwVkTextArea class is simply a specialisation of the “TextArea”class in the “java.awt” package. It additionally manages a boolean valuewhich specifies the use (or not) of the virtual keyboard.

The constructors are exactly the same as those of the “TextArea” classin the “java.awt” package, with a simple additional argument: a booleanspecifying the use of the virtual keyboard.

If the boolean is “true”, a ‘base’ instance of the “TextArea” class iscreated, and a virtual keyboard listener, available within the currentapplication, is also added at the same time, using the “addKeyListener”method. If not, a ‘normal’ TextArea is created.

When the TextArea has the focus, if the user presses ‘OK’ and theboolean specifies the use of the virtual keyboard, the virtual keyboardis displayed and gains the focus. It manages all of the events and isable to fill the text field. If the user presses ‘OK’ again, its text isvalidated, and the keyboard returns the focus. If the use of the virtualkeyboard is not envisaged (boolean=false), the “TextArea” has the same‘behaviour’ as a standard TextArea in “java.awt”.

The following section describes further the implementation of featuresdescribed above, and in particular the reconstruction of graphicalobjects (for example text fields, buttons, sliders, lists, checkboxes,choices etc.) from a set of graphical elements.

FIG. 39 shows a button, for example, which is made from 9 elements: thefour corners (NW 2100, NE 2101, SW 2102, SE 2103), the four sides (N2104, E 2105, W 2106, S 2107) and the centre (C 2108).

Typically, but not necessarily, each of these 9 elements is square (4×4pixels, 8×8 pixels, 16×16 pixels). The blocks of N, E, W, S and Celements are tiled within the area required (defined by the size of thecomponent together with the border defined by the look). This area doesnot have to be a multiple of the size of the element. Currently, thetiling goes from left to right or top to bottom, so any incompletelydrawn elements appear at the bottom and right hand sides. It could beenvisaged to add “centered” and “right” justified tiling rules if thiswas felt to be useful. In general, the NW, NE, SW and SE elements arethe same size as the border and so tiling is not necessary. If, however,they are smaller than required, the tiling is performed automatically.

A brief description follows of how this is implemented. The work isdivided into three areas: the mechanism built into the native WGT moduleallowing the creation and assignment of different looks to different WGTwidgets; the development of the native “LookPixmap” module, in which thefunctions for painting the different graphical features of componentsare included; and the development of the mhw.awt Java package forinterfacing with the native code.

These three areas of development are described in the followingsections.

The WGT module look mechanism will now be described, with references toFIGS. 40 and 41.

The aim of this section is to describe how the WGT module has beenmodified so as to be able to control the ‘look’ of the various graphicobjects managed. New looks can be defined in new classes which can beadded as and when necessary, leaving the WGT module untouched. Astandard WGT look (LookWgt) is provided, instantiated and attributed towidgets by default so that applications not wishing to use this facilitydo not need to use it.

The following features are required: a number of different looks can bedefined for each object type; a different look can be given to eachobject independently; and by default, the look defined by the currentWGT is applied to objects.

Two different techniques for drawing the look of an object must bepossible: bitmap and vectorial.

In the bitmap technique, the object is drawn by combining a number ofpredefined bitmap elements to create a single bitmap which is thendrawn. To create objects of variable size, elements can be repeated,along the sides for example, in order to build an object of the requiredsize.

Neither the size nor the precise arrangement of each of these elementsis defined. The idea is to leave this as free as possible so that thecreation of new looks is not overly restricted by WGT. The look classmust define the bitmap elements and the rules for fitting them togetheras a function of the object size required.

The LookPixmap (native) and the PixmapLook (Java) classes describedlater use this method exclusively. There is nothing to stop developerscreating their own look, derived or not from LookPixmap, which usesvectorial methods.

In the vectorial technique, the object is drawn using a series of basicdraw operations such as DrawRectancle( ), DrawArc( ). The look classmust define the rules for drawing the object as a function of the objectsize required.

It is perfectly possible to envisage a look class combining both Bitmapand Vectorial techniques. For example, the bitmap approach could be usedfor the basic form of a button, while the vectorial approach couldprovide the highlighting.

The WGT Module Look Mechanism are now discussed in more detail.

The following mechanisms have been incorporated:

-   -   Division of the current paint method for each object into seven        functions, certain of which are contained in the look class        attributed to the object: DrawBackground( );        MhwWgtLookDrawBackground( ); DrawForeground( );        MhwWgtLookDrawForeground( ); MhwWgtLookDrawRelief( );        MhwWgtLookDrawFocus( ); MhwWgtLookHighlight( )    -   Creation of an abstract class MhwWgtLook.    -   Creation of a class MhwWgtLookWgt derived from MhwWgtLook, and        instantiated when WGT is initialized.    -   Addition of a g_TheDefaultLook global variable used to set the        look that will be attributed to each object when it is created        if a specific look is not attributed MhwWgtXXXAttsSetLook.    -   Addition of a public method MhwWgtSetDefaultLook(context) for        changing the default look for objects.    -   Addition to the object classes of two public methods,        MhwWgtSetXXXAttrLook(*object, *look) and        MhwWgtGetXXXAttsLook(*object).

These aspects are presented in the following sections, beginning withthe methods for painting.

Each paint function now calls the following methods when it is called:DrawBackground( ); MhwWgtLookDrawBackground( ); DrawForeground( );MhwWgtLookDrawForeground( ); MhwWgtLookDrawRelief( );MhwWgtLookDrawFocus( ); and MhwWgtLookHighlight( ).

The two methods DrawBackground( ) and DrawForeground( ) are part of WGTand are called regardless of the look. The others are, in fact, pointersto the corresponding functions in the Look class associated with thewidget in question. In this way, the look class implements the paintfunctions for these parts.

Background This allows the look to draw behind the entire widget.Foreground This can be used to draw an image of other graphic over thecentral part of the widget (excluding the border). Relief This is calledif the widget's relief flag is set and is used to draw a border orrelief for the widget. Focus This is called if the widget has the focus.It can be used to indicate this graphically. Highlight This is called ifthe widget is highlighted. It can be used to indicate this graphically.

The abstract class MhwWgtLook is defined and contains the following:WgtCoreLookClassMethod; WgtCoreLookClassField; WgtCoreLookClass;WgtCoreLookPart; and WgtCoreLookObject.

These are described below.

FIELDS: MhwWgtLookClass *extends; Int32 classId; String ClassName;Card16 mask; Card8 borderwidthTop; Card8 borderwidthBottom: Card8borderwidthLeft; Card8 borderwidthRight; MhwWgtColorMapId Colormap:MhwWgtVisual visual; Card32 blackPixel; Card32 whitePixel; Card32transparentPixel; MhwWgtColor verylightGray; MhwWgtColor lightGray;MhwWgtColor middleGray; MhwWgtColor darkGray; MhwWgtColor highlight;MhwWgtColor blackColor; MhwWgtColor whiteColor; METHOD TABLE (set topoint to the overloaded methods in derived classes): MhwWgtError(*delete) (MhwWgtLook); MhwWgtErrox (*free) (MhwWgtLook); MhwWgtError(*reference) (MhwWgtLook); Card8 (*getBorderWidth) (MhwWgtLook,MhwWgtWidget, MhwWgtLookBorder); MhwWgtError (*getBorderWidth)(MhwWgtLook, MhwWgtLookBorder, Card8); Bool (*isInstanceOf) (MhwWgtLook,Int32); MhwWgtError (*drawBackground) (MhwWgtLook, MhwWgtWidget, Int16,Int16, Card16, Card16); MhwWgtError (*drawForeground) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16); MhwWgtError (*drawRelief)(MhwWgtLook, MhwWgtWidget, Int16, Int16, Card16, Card16,MhwWgtLookRelief); MhwWgtError (*unDrawRelief) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16); MhwWgtError (*drawFocus)(MhwWgtLook, MhwWgtWidget, Int16, Int16, Card16, Card16); MhwWgtError(*unDrawFocus) (MhwWgtLook, MhwWgtWidget, Int16, Int16, Card16, Card16);MhwWgtError (*drawHighlight) (MhwWgtLook, MhwWgtWidget, Int16, Int16,Card16, Card16); MhwWgtError (*unDrawHighlight) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16); MhwWgtError (*drawInset)(MhwWgtLook, MhwWgtWidget, Int16, Int16, Card16, Card16); MhwWgtError(*drawOutset) (MhwWgtLook, MhwWgtWidget, Int16, Int16, Card16, Card16).MhwWgtError (*drawSelectedBG) (MhwWgtLook, MhwWgtWidget, Int16, Int16,Card16, Card16); MhwWgtError (*drawCheckSymbol) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16, Bool, MhwWgtCheckStyle):MhwWgtError (*drawChoiceSymbol) (MhwWgtLook, MhwWgtWidget, Int16, Int16,Card16, Card16); MhwWgtError (*drawAnchor) (MhwWgtLook, MhwWgtWidget,Int16, Int16, Card16, Card16, String, Card32, Int8, MhwWgtLookItemFlag,MhwWgtColor); MhwWgtError (*drawCross) (MhwWgtLook, MhwWgtWidget, Int16,Int16, Card16, Card16); MhwWgtError (*unDrawCross) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16); MhwWgtError (*drawItem)(MhwWgtLook, MhwWgtWidget, Int16, Int16, Card16, Card16, String. Card32,Int8, MhwWgtLookItemFlag); MhwWgtError (*reDrawItem) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16, String, Card32, Int8,MhwWgtLookItemFlag, Bool); MhwWgtError (*drawSlidArrow) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16, MhwWgtSlidDirection);MhwWgtError (*drawSlidLift) (MhwWgtLook. MhwWgtWidget. Int16, Int16,Card16, Card16); MhwWgtError (*drawCursor) (MhwWgtLook, MhwWgtWidget,Int16. Int16, Card16, Card16); MhwWgtError (unDrawCursor) (MhwWgtLook,MhwWgtWidget, Int16, Int16, Card16, Card16); MhwWgtError (*drawString)(MhwWgtLook, MhwWgtWidget, Int16, Int16, String, Card32, Int8);MhwWgtDimension (*getPreferredSizeArrow) (MhwWgtLook); MhwWgtDimension(*getPreferredSizeCheck) (MhwWgtLook); MhwWgtDimension(*getPreferredSizeChoice) (MhwWgtLook); MhwWgtDimension(*getPreferredSizeCross) (MhwWgtLook); Card8 (*getItemBorderwidth)(MhwWgtLook);

(The Card8, Card16, etc. data types are aliases for number types havingthe indicated number of bits, e.g. Card8 is equivalent to a ‘char’,Card16 is equivalent to a ‘short’, etc.)

Each draw method is identical for each object type. For looks whichrequire a different method for each method, or at least for certainmethods, the method in the look class must identify the widget type andact accordingly.

Note the purpose of the DrawNothing( ) method. It simply returns OK ifcalled. Certain features are not necessarily implemented in a givenlook. So that WGT does not necessarily have to test the existence of agiven function, any unimplemented functions should point to this method.

Note also Mask. This is a private, read-only Boolean array where eachelement corresponds to one of the above methods. If an element is set to1, then the corresponding method is redefined. Otherwise, the method isnot redefined. In this way, if it wants to, WGT can find out in a singleoperation which methods it has to call.

The look class is used to define the interface between any lookdefinition and WGT. WGT uses only these methods to display the requiredlook. If additional functionality is required of a look, it can beincorporated in an extended look structure, but it is up to theapplication and not WGT to take these methods/parameters into account.In this way, additional attributes and methods can be added.

A derived look structure must contain all these methods and attributes,and it can also add its own. However. WGT will only take those methodsdefined in the MhwWgtLook structure into account.

The MhwWgtLookWgt class is now discussed.

So that existing applications do not have to be modified to remaincompatible with the modified version of WGT, a basic look class,defining the look that WGT objects currently have, is created andinstantiated by WGT.

It is a sub-class of MhwWgtLook and is called MhwWgtLookWgt. When thisclass is initialised, the values of all of the pointers in the structureare set to point at the WGT-defined methods.

This basic class contains nothing else—it simply defines the look thatWGT currently provides.

FIELDS: Card8 reliefWidth MhwWgtColor reliefColorWhite; MhwWgtColorreliefColorBlack; Card8 focusWidth; MhwWgtColor focusColor; Card8highlightWidth; MhwWgtColor highlightColor; MhwWgtColoranchorColorBGNormal; MhwWgtColor anchorColorFGVisited: MhwWgtColoranchorColorBGCurrent: Card16 mask; Card8 reliefWidth; MhwWgtColorreliefColorWhite; MhwWgtColor reliefColorBlack; Card8 focusWidth;MhwWgtColor focusColor; Card8 highlightWidth; MhwWgtColorhighlightColor; MhwWgtColor anchorColorBGNormal; MhwWgtColoranchorColorFGVisited; MhwWgtColor anchorColorBGCurrent; MhwWgtColorMapIdcolorMap; Card32 blackPixel; Card32 whitePixel; Card32 transparentPixel;MhwWgtColor verylightGray; MhwWgtColor lightGray; MhwWgtColormiddleGray; MhwWgtColor darkGray: MhwWgtColor highlight; MhwWgtColorblackColor; MhwWgtColor whiteColor; METHOD TABLE: MhwWgtError(*setReliefWidth) (MhwWgtLkWgt, Card8); MhwWgtError(*setReliefColorBlack) (MhwWgtLkWgt, MhwWgtColor); MhwWgtError(*setReliefColorWhite) (MhwWgtLkWgt, MhwWgtColor); MhwWgtError(*setFocusWidth) (MhwWgtLkWgt, Card8); MhwWgtError (*setFocusColor)(MhwWgtLkWgt, MhwWgtColor); MhwWgtError (*setHighlightWidth)(MhwWgtLkWgt, Card8); MhwWgtError (*setHighlightColor) (MhwWgtLkWgt,MhwWgtColor); MhwWgtError (*setAnchorColorBGNormal) (MhwWgtLkWgt,MhwWgtColor); MhwWgtError (*setAnchorColorFGVisited) (MhwWgtLkWgt,MhwWgtColor); MhwWgtError (*setAnchorColorBGCurrent) (MhwWgtLkWgt,MhwWgtColor);

With regard to the WGT initialisation, an instance of the MhwWgtLookwgtclass must be created when the WGT is started. WGT will thus have accessto these methods if the application does not specify a different look.The g_TheDefaultLook global variable (described below) must initially beset to point at this look.

The processes of defining new Looks and setting default Looks are nowdescribed.

WGT is not responsible for defining or instantiating new look objects.Applications must do this themselves. All look objects created must becastable in an MhwWgtLook structure. C.f the management of Looks below.

With regard to default looks, a field:

MhwWgtLook *DefaultLook

must be added to the MhwWgtContext object pointing to the instance ofMhwWgtLook to be applied to any new objects created from this context.When a new WGT context is created, this field must be set to point atWgtBasicLook.

With regard to setting the default Look for a Context, a public method:

MgwWgtSetDefaultLook(MhwWgtContext, aContext, MhwWqtLook aLook)

is provided to set the DefaultLook field in aContext to point at aLook.

For associating a Look with an Object, the following attribute is addedto the coreAtts structure in the core class:

MhwWgtLook *Look

This attribute is thus created for each object created. Whenever aobject is instantiated, Look is set to point at the DefaultLook globalvariable.

Two new public methods MhwWgtSetXXXAttsLook(MhwWgtWidget anObject,MhWWgtLook aLook) and MhwWgtGeXXXAttsLook(MhwWgtWidget anObject,MhwWgtLook *aLook) should be added to the core class to allow the lookinstance associated with the object to be changed.

The management of Looks is now discussed.

WGT does not provide any look management. In order to use a look otherthan the default, an application must first ensure that one or more lookclasses are instantiated and initialised, and then each time that itcreates a new WGT object, use the MhwWgtSetCoreAttsLook( ) method toassociate the object with the desired look. If it wishes to use a givenlook for all future widgets, it can use the MhwWgtSetDefaultLook( )method described above.

An application wishing to use any look other than the one defined bydefault is responsible for creating and instantiating the look. Inanother embodiment of the invention, an application may download looksremotely. In this case, however, the application itself must supply therequired classes, derived from MhwWgtLook.

A look must not be destroyed by the application that created it untilall the widgets which use it have been destroyed. This requires theaddition of a refCounter field to count the number of “clients”.

look=MhwNewLook( )

MhwLookRef(look);

.

.

.

MhwLookUnref(look);

Look=0;

This replaces free (look). The look will actually be destroyed when itsrefCounter field equals 0.

SetXxxLook(widget, look) {

if(widget->core.look)

-   -   MhwLookUnref(widget->core.look);

widget->core.look=look;

if(look)

-   -   MhwLookRef(look);

}

The WGT Module List of APIs for implementing Looks is given here:

extern MhwWgtError MhwWgtLookInitDefault (MhwWgtLookClass*,MhwWgtLookAtts*); extern MhwWgtError MhwWgtLookinitClass (Void); externMhwWgtError MhwWgtLookResetDefault (MhwWgtLookClass*); externMhwWgtError MhwWgtLookAttsGetBorderWidthBTLR (MhwWgtLookAtts*, Card8*,Card8*, Card8*, Card8*); extern MhwWgtErrorMhwWgtLookAttsGetBorderWidthBottom (MhwWgtLookAtts*, Card8*); externMhwWgtError MhwWgtLookAttsGetBorderWidthLeft (MhwWgtLookAtts*, Card8*);extern MhwWgtError MhwWgtLookAttsGetaorderWidthRight (MhwWgtLookAtts*,Card8*); extern MhwWgtError MhwWgtLookAttsGetBorderWidthTop(MhwWgtLookAtts*, Card8*); extern MhwWgtError MhwWgtLookAttsGetDefault(MhwWgtLookClass*, MhwWgtLookAtts*) extern MhwWgtErrorMhwWgtLookAttsInit (MhwWgtLookAtts*); extern MhwWgtErrorMhwWgtLookAttsSetBorderWidthBTLR (MhwWgtLookAtts*, Card8, Card8, Card8,Card8); extern MhwWgtError MhwWgtLookAttsSetBorderWidthBottom(MhwWgtLookAtts*, Card8); extern MhwWgtErrorMhwWgtLookAttsSetBorderWidthLeft (MhwWgtLookAtts*, Card8); externMhwWgtError MhwWgtLookAttsSetBorderWidthRight (MhwWgtLookAtts*, Card8);extern MhwWgtError MhwWgtLookAttsSetBorderWidthTop (MhwWgtLookAtts*,Card8);

The Look/LookPixmap module will now be described in more detail.

The MhwWgtLookPixmap class is derived from the MhwWgtLook classdescribed above. Essentially it works by reconstructing the variouselements of each component to create a graphical image of the requiredsize, as described above.

These images are used for the following: backgrounds for buttons; relief(that is the border around the active zone of text areas, for example);a symbol for the Choice component; checkboxes; sliders; and sliderlifts.

With reference to FIG. 40, to reduce initialization time, the images arenot compressed, but are stored in a special format designed to minimizeas far as possible the space occupied. The colour of each pixel (2152)is described in a single byte, which is the index number (2151) of thecolour in the current colourmap. FIG. 40 shows an example buffer, image,containing an 4×4 image (2153).

The image (2153) in FIG. 40 would be stored as follows:

Card8 slidLiftSeVrImage4 [4] [4] = {  { 0, 0, 0, 1},  { 0, 0, 1, 2},  {0, 1, 2, 3},  { 1, 2, 3, 4} };

The LookPixMap Image structure will now be described.

In order to identify the size of an image buffer, a structure,LookPixmapImage, is defined including the image buffer described above,together with the width and height of the image. This structure, definedbelow, is used to contain the data for each graphical element.

typedef struct { Card8 *imageData; Buffer containing the image. It is atwo dimensional array of Card8, each element of which contains the indexnumber in the palette of the colour to be displayed at the position inthe array. Card8 *maskData; Buffer containing the mask. It is a onedimensional array of Card8, with one bit per pixel. (Format as returnedby the Image module). Card16 width; Width of the image. Card16 height;Height of the image. Card8 isOpaque; 0 if image contains any transparentelements, 1 if entirely opaque. } LookPixmapImage;

Images can be of different sizes, although for a given type of elementthey will generally be the same. The central element (xxxxxC), however,is often of size 1×1. The MhwWgtLookPixmapAllImages structure groupstogether all the picture elements as shown below:

typedef struct { LookPixmapImage *relnoNW; NorthWest corner of relief -state Normal LookPixmapImage *relnoSW; SouthWest corner of relief -state Normal LookPixmapImage *relnoNE; NorthEast corner of relief -state Normal LookPixmapImage *relnoSE; SouthEast corner of relief -state Normal LookPixmapImage *relnoN; North edge of relief - stateNormal LookPixmapImage *relnoW; West edge of relief - state NormalLookPixmapImage *relnoE; East edge of relief - state NormalLookPixmapImage *relnoS: South edge of relief - state NormalLookPixmapImage *relnoC; Central area of relief - state NormalLookPixmapImage *relfoNW; State - Focus only LookPixmapImage *relfoSW;LookPixmapImage *relfcNW; LookPixmapImage *relfoSE; LookPixmapImage*relfoN; LookPixmapImage *relfoW; LookPixmapImage *relfoE;LookPixmapImage *relfoS; LookPixmapImage *relfoC; LookPixmapImage*relhiNW; State - Highlight only LookPixmapImage *relhiSW;LookPixmapImage *relhiNE; LookPixmapImage *relhiSE; LookPixmapImage*relhiN; LookPixmapImage *relhiW; LookPixmapImage *relhiE;LookPixmapImage *relhiS; LookPixmapImage *relhiC; LookPixmapImage*relfhNW; State - Focus and Highlight LookPixmapImage *relfhSW;LookPixmapImage *rolfhNE; LookPixmapImage *relfhSE; LookPixmapImage*relfhN; LookPixmapImage *relfhW; LookPixmapImage *relfhE;LookPixmapImage *relfhS: LookPixmapImage *relfhC; LookPixmapImage*butnoNW; Button elements LookPixmapImage *butnoSW: LookPixmapImage*butnoNE; LookPixmapImage *butnoSE; LookPixmapImage *butnoN;LookPixmapImage *butnoW: LookPixmapImage *butnoE: LookPixmapImage*butnoS; LookPixmapImage *butnoC; LookPixmapImage *butfoNW;LookPixmapImage *butfoSW; LookPixmapImage *butfoNE; LookPixmapImage*butfoSE; LookPixmapImage *butfoN; LookPixmapImage *butfoW;LookPixmapImage *butfoE; LookPixmapImage *butfoS; LookPixmapImage*butfoC; LookPixmapImage *buthiNW; LookPixmapImage *buthiSW;LookPixmapImage *buthiNE; LookPixmapImage *buthiSE; LookPixmapImage*buthiN; LookPixmapImage *buthiW; LookPixmapImage *buthiE;LookPixmapImage *buthiS; LookPixmapImage *buthiC; LookPixmapImage*butfhNW; LookPixmapImage *butfhSW; LookPixmapImage *butfhNE;LookPixmapImage *butfhSE; LookPixmapImage *butfhN; LookPixmapImage*butfhW; LookPixmapImage *butfhE; LookPixmapImage *butfhS;LookPixmapImage *butfhC; LookPixmapImage *choice; Choice SymbolLookPixmapImage *chck1na, Checkbox symbol - Type 1 not selected no focusLookPixmapImage *chck1a; Checkbox symbol - Type 1 selected no focusLookPixmapImage *chckf1na; Checkbox symbol - Type 1 not selected focusLookPixmapImage *chckf1a: Checkbox symbol - Type 1 selected focusLookPixmapImage *chck2na; Checkbox symbol - Type 2 not selected no focusLookPixmapImage *chck2a; Checkbox symbol - Type 2 selected no focusLookPixmapImage *chckf2na; Checkbox symbol - Type 2 not selected focusLookPixmapImage *chckf2a; Checkbox symbol - Type 2 selected focusLookPixmapImage *slidNeVr; Slider background elements LookPixmapImage*slidEVr; LookPixmapImage *slidSeVr: LookPixmapImage *slidSwHr:LookPixmapImage *slidSHr; LookPixmapImage *slidSeHr; LookPixmapImage*slidSeVrHr; LookPixmapImage *slidLiftNeVr; Slider lift elementsLookPixmapImage *slidLiftEVr; LookPixmapImage *slidLiftSeVr,LookPixmapImage *slidliftSwHr; LookPixmapImage *slidLiftSHr;LookPixmapImage *slidLiftSeHr; } MhwWgtLookPixmapAllImages;

This section describes the LookPixmap module, including the LookPixmapclass, which has been created to allow a set of different looks to beapplied to the Web Browser.

This module contains the following source files: MhwWgtLookPixmap.h;

MhwWgtLookPixmapStruct.h; WgtLookPixmapClass.c; WgtLookPixmapPrivate.c;

MhwWgtLookPixmalImages.h; MhwWgtLookPixmapImages2.h;

MhwWgtLookPixmapImages3.h; MhwWgtLookPixmapImages4.h;

MhwWgtLookPixmapImages5.h; and MhwWgtLookPixmapImages6.h.

The LookPixmap Module will now be described, including details of thepreferred method of creating and using LookPixmap Objects.

Any software using WGT for the creation and management of Widgets canuse the LookPixmap module to provide alternative looks to the WGTwidgets. For an application to use the LookPixmap look, a LookPixmapobject must be created. This can be done using the following code:

MhwWgtLkWebClass PixmapLook; MhwWgtLkWeb PixmapLookObject;MhwWgtLkWebAtts LookPixmapValues; MhwWgtError WgtErr;

WgtErr = MhwWgtLkWebInitClass ( );

WgtErr = MhwWgtLkWebAttsInit (&LookPixmapValues);

WgtErr = MhwWgtLkWebInitDefault (&PixmapLook, &LookPixmapValues);

PixmapLookObject = MhwWgtLkWebNew (&LookPixMapValues);

A method for setting the default look is now described.

An application can use a given look object by default. By default. thedefault look is the LookWgt object created by WGT. In order to setanother default look, on condition that it has already been created asdescribed above. the following function can be used:

MhwWgtSetDefaultLook ((MhwWgtLook) PixmapLookObject);

All subsequent WGT widgets created will be associated with theLookPixmap look class and not the WGT default LookWgt

An application can choose or set a look for a given type of widget, or agiven widget, as will now be described.

An application can set the look for a given widget when the object iscreated by calling the following function just before the widget iscreated:

MhwWgtXXXAttsSetLook (MhwWgtXXXAtts*, MhwWgtLook);

It can also set the look of an object after creation using the followingfunction:

MhwWgtXXXsetLook (MhwWgtXXXWidget *, MhwWgtLook);

(where xxx is the type of widget—eg LIST).

The method of using LookPixmap Images is now described.

A single LookPixmap object uses a single set of images. You canobviously change the look dramatically, simply by changing the images.

You can change the images used for a given LookPixmap object by callingthe following functions:

MhwWgtLookPixmapSetImages (MhwWgtLookPixmap *,MhwWgtLookPixmapAllImages*);

Sets the images used for all widgets using the specified LookPixmapobject to the specified image set.

MhwWgtLookPixmapSetDefaultImages (MhwWgtLookPixmap*);

Sets the images used for all widgets using the specified LookPixmapobject to the default image set.

If you wish to use different images for different widgets, you mustcreate a LookPixmap object for each set of images required. You thenassign each image set to the appropriate look, and then associate eachlook to the appropriate widget.

The API of the LookPixmap module will now be described, with referenceto FIGS. 39 and 41.

The following public APIs are available:

MhwWptLookPixmapSetImages( )

Prototype:

MhwWgtError MhwWgtLookPixmap (MhwWgtLkWeb aLook, SetImagesMhwWgtLookPixmapAllImages* someImages);

Description

Sets the set of images used by aLook to the set of images pointed to bysomeImages.

Parameters: aLook The MhwWgtLkWeb object to which to associate theimages, someImages someImages The set of images to associate with aLook.Returns: MHW_WGT_SUCCESSMhwWgtLookPixmapSetImagesID( )

Prototype:

MhwWgtError (MhwWgtLkWeb aLook, Card8 MhwWgtLookPixmapSetImagesIDanImageID);

Description

Sets the set of images used by aLook to the set of imageshard-programmed in MhwWgtLookPixMap and identified by anImageID.

Parameters: aLook The MhwWgtLkWeb object to which to associate theimages identified by anImageID. anImageID The identifier of the set ofimages, hard- programmed in MhwWgtLookPixmap, to associate with aLook.Returns: MHW_WGT_SUCCESSMhwWgtLookPixmapSetDefaultImages( )

Prototype:

MhwWgtError (MhwWgtLkWeb aLook); MhwWgtLookPixmapSetDefaultImages

Description

Sets the set of images used by aLook to the set of imageshard-programmed in MhwWgtLookPixmap and identified by the identifier 1.

Parameters: aLook The MhwWgtLkWeb object to which to associate theimages identified by anImageID. Returns: MHW_WGT_SUCCESSMhwWgtLookPixmapLoadImage( )

Prototype:

MhwWgtError (MhwWgtLkWeb aLook, Int32 MhwWgtLookPixmapLoadImageanElementID, Int32 aWidth, Int32 aHeight, Card8* anImageBuffer);

Description:

Used to change a single image pointed to by the currentMhwWgtLookPixmapAllImages structure to point at the specified image.Creates an LookPixmapImage structure and sets the currentMhwWgtLookPimapAllImages structure pointed to by aLook to point at thisLookPixmapImage for the element specified by anElementID.

Parameters: aLook The MhwWgtLkWeb object to which to associate theimages identified by anImageID. anElementID The identifier of theelement to change. aWidth The width, in pixels, of the new image.aHeight The height, in pixels, of the new image. anImageBuffer Thebuffer containing the new image data. Returns: MHW_WGT_SUCCESSLookPixmapMakeImageFromElements( )

Prototype:

MhwWgtError (LookPixmapImage* elemN, LookPixmapMakeImageFromElementsLookPixmapImage* elemE, LookPixmapImage* elemW, LookPixmapImage* elemS,LookPixmapImage* elemNW, LookPixmapImage* elemE, LookPixmapImage*elemSW, LookPixmapImage* elemSE, LookPixmapImage* elemC, Card16 anX,Card16 aY, Card16 aWidth, Card16 aHeight, MHWWindowID aWindow,LookPixmapDrawMode aDrawMode);

Description:

Takes the nine images of elemX and draws them in the specified MHWwindow. The rules for constructing the image are specified by aDrawMode(currently only MHW_WGT_LIKWEB_DRAW_NORMAL exists). The final image isdrawn in the window with the top left corner positioned at (anX, aY) andof size aWidth×aHeight.

If one or more of the elements have zero size (either elemXX.width orelemXX.height is zero) this element is not drawn.

Parameters: elemN, elemE, elemW, elemS, elemNW, elemNE, elemSW, elemSE,elemC: the image to draw at the top, right, left, bottom, top leftcorner, top right corner, bottom left corner, bottom right corner andmiddle, respectively. αnX The x-position in the window, aWindow, to drawthe final image. αY The y-position in the window, aWindow, to draw thefinal image. αWidth The width, in pixels, of the new image. αHeight Theheight, in pixels, of the new image. αWindow The window in which to drawthe constructed image. αDrawMode The mode in which to construct theimage. MHW_WGT_LKWEB_DRAW_NORMAL: Puts the NW (2100), NE (2101), SW(2102) and SE (2103) elements in the four corners (2200, 2201, 2202,2203) with no tiling. Horizontally tiles the N and S elements.Vertically tiles the W and E elements. Tiles both horizontally andvertically the C element. Although it will work for any image sizes, itis only guaranteed to correctly tile the area provided that the centralarea (2208) is rectangular. Returns: MHW_WGT_SUCCESS

The Mhw.awt Java Interface Package will now be described.

Three Java classes have been developed so that the Look mechanismdefined in WGT can be exploited by java applications. These are:mhw.awt.Look; mhw.awt.WgtLook; and mhw.awt.PixmapLook.

The Look class is the abstract class corresponding to the classMhwWgtLook described above.

The WgtLook class is used to create and handle instances of the WGTclass MhwWgtLookWgt.

The PixmapLook class is used to store the images used by the WgtLookclass.

The Mhw.awt.PixmapLook API will now be described, beginning with detailsof the constructors.

PixmapLook

public PixmapLook( )

Creates a new instance of a PixmapLook object, with the imagesinitialised to the default images (ID=1).

PixmapLook

public PixmapLook (int imageID)

Creates a new instance of a PixmapLook object, with the imagesinitialised to the images specified by imageID.

The methods will now be described.

SetImages

public void SetImages( )

Set the current images for this PixmapLook object to the default (ID=I)

SetImages

public void SetImages (int imageID)

Set the current Images for this PixmapLook object to the imagesspecified by imageID.

LoadImage

public void LoadImage (int elementID, int width, int height, byte[ ]buffer)

Loads a specified image element. Each PixmapLook object has a set of(94) images associated with it. These images represent the graphiccomponent elements as follows: 0 relnoNW; 1 relnoSW; 2 relnoNE; 3relnoSE; 4 relnoN; 5 relnoW; 6 relnoE; 7 relnoS; 8 relnoC; 9 relfoNW; 10relfoSW; 11 relfoNE; 12 relfoSE, 13 relfoN; 14 relfoW; 15 relfoE; 16relfoS; 17 relfoC; 18 relhiNW; 19 relhiSW; 20 relhiNE; 21 relhiSE; 22relhiN; 23 relhiW; 24 relhiE; 25 relhiS; 26 relhiC; 27 relfhNW; 28relfhSW; 29 relfhNE; 30 relfhSE; 31 relfhN; 32 relfhW; 33 relfhE; 34relfhS; 35 relfh C; 36 butnoNW; 37 butnoSW; 38 butnoNE; 39 butnoSE; 40butnoN; 41 butnoW; 42 butnoE; 43 butnoS; 44 butnoC; 45 butfoNW; 46butfoSW; 47 butfoNE; 48 butfoSE; 49 butfoN; 50 butfoW; 51 butfoE; 52butfoS; 53 butfoC; 54 buthiNW; 55 buthiSW; 56 buthiNE; 57 buthiSE; 58buthiN; 59 buthiW; 60 buthiE; 61 buthiS; 62 buthiC; 63 butfhNW; 64butfhSW; 65 butfhNE; 66 butfhSE; 67 butfhN; 68 butfhW; 69 butfhE; 70butfhS; 71 butfhC; 72 choice; 73 chcklno; 74 chcklse; 75 chcklfo; 76chcklfs; 77 chck2no; 78 chck2se; 79 chck2fo; 80 chck2fs; 81 slidNeVr, 82slidEVr, 83 slidSeVr; 84 slidSwHr, 85 slidSHr; 86 slidSeHr; 87slidSeVrHr; 88 slidLiftNeVr, 89 slidLiftEVr, 90 slidLiftSeVr; 91slidLiftSwHr; 92 slidLiftSHr, 93 slidLiftSeHr.

width specifies the width of the image passed.

height specifies the height of the image passed.

buffer contains the image data. This is in the form of a byte array,each byte giving the colormap index to be used for each pixel. The indexused for pixel (x,y) is buffer[(y*width)+x].

MakeImageFromElements

public void MakeImageFromElements (int[ ] widths, int[ ] heights, byte[][ ] buffers, int anX, int aY, int aWidth, int aHeight,java.awt.Component aComponent)

Constructs an image based on 9 elements (N, E, W, S, NW, NE, SW, SE, C)and draw it on the window associated with the component aComponent withthe top left corner at (anX, aY) and with size aWidth×aHeight. The imagebuffers are passed as a two dimensional array, one dimension giving theimage number (0–8 corresponding to N, E, W, S, NW, NE, SW, SE, C) andthe other containing the data. The widths and heights of each buffer aregiven in the arrays widths and heights.

DownloadLookDir

public java.lang.String DownloadLookDir( )

Downloads a “look” directory from the MPEG stream. Returns a stringcontaining information on each set of look images which can bedownloaded separated by newlines. The line number of a title (0 to n−1)corresponds to the identifier (ImageSet) to be used with the functionDownLoadLookImages(int ImageSet).

The directory is in fact a simple text file containing the string thatis returned. The file path is hard coded in the source—currently/home/users/mstoddar/mhplus/util/looks/images.dir. This can be changedas appropriate. This can thus be used in the decoder to automaticallydownload from the MPEG stream.

The format of the file is:

<Image Set Title 1>\t<>Image Set Descriptions><\t><URLResoucrce><\t><URL Preview><\n>

<Image Set Title 2><\t<Image Set Description><\t><URL Resource><\t><URLPreview><\n>

<Image Set Title 3><\t><Image Set Description><\t><URL Resource><\t><URLPreview><\n>

<Image Set Title 4><\n><Image Set Description><URL Resource><\t><URLPreview><\n>

Returns “ ” if unsuccessful.

DownloadLookImages

public void DownloadLookImages (int ImageSet)

Downloads a new set of images from the MPEG stream, identified by theline number (0 to n−1) of one of the entries returned inDownLoadLookDir( ), and attributes them to this look.

The file containing the data is in the following format:

WWWWHHHHWWWWHHHH . . . a series of four byte strings (leading spaces)containing the decimal values of the widths and heights of all 94 images(in the same order as in the method LoadImage( )). The data buffers foreach image follow, again in the same format as LoadImage( ). Noalignment is made between images, the beginning of the next imagestarting at the byte following the previous one.

The file path is hard coded in the source—currently/home/users/mstoddar/mhplus/util/looks/images.<ImageSet>. This can bechanged as appropriate. This can thus be used in the decoder toautomatically download from the MPEG stream.

public void DownloadLookImages (string ImageURL)

Downloads a new set of images from the MPEG stream, identified by theURL specified, and attributes them to this look.

The file containing the data is in the format given above.

The structure of the file is given below in C syntax for clarity:

-   Card8 relnoNWwidth[4π String representation of decimal value    (leading spaces)-   Card8 relnoNWheight[4]-   Card8 relnoSWwidth[4]-   Card8 relnoSWheight(4]-   Card8 relnoNEwidth[4]-   Card8 relnoNEheight[4]-   Card8 reinoSEwidth[4]-   Card8 relnoSEheight[4]-   Card8 relnoNwidth[4]-   Card8 relnoNheight[4]-   Card8 relnoWwidth[4]-   Card8 relnoWheight[4]-   Card8 relnoEwidth[4]-   Card8 relnoEheight[4]-   Card8 relnoSwidth[4]-   Card8 relnoSheight[4]-   Card8 relnoCwidth[4]-   Card8 relnoCheight[4]-   Card8 relfoNWwidth[4]-   Card8 relfoNWheight[4]-   Card8 relfoSWwidth[4]-   Card8 relfoSWheight[4]-   Card8 relfoNEwidth[4]-   Card8 relfoNEheight[4]-   Card8 relfoSEwidth[4]-   Card8 relfoSEheight[4]-   Card8 relfoNwidth[4]-   Card8 relfoNheight[4]-   Card8 relfoWwidth[4]-   Card8 relfoWheight[4]-   Card8 relfoEwidth[4]-   Card8 relfoEheight[4]-   Card8 relfoSwidth[4]-   Card8 relfoSheight[4]-   Card8 relfoCwidth[4]-   Card8 relfoCheight[4]-   Card8 relhiNWwidth[4]-   Card8 relhiNWheight[4]-   Card8 relhiSWwidth[4]-   Card8 relhiSWheight[4]-   Card8 relhiNEwidth[4]-   Card8 relhiNEheight[4]-   Card8 relhiSEwidth[4]-   Card8 relhiSEheight[4]-   Card8 relhiNwidth[4]-   Card8 relhiNheight[4]-   Card8 relhiWwidth[4]-   Card8 relhiWheight[4]-   Card8 relhiEwidth[4]-   Card8 relhiEheight[4]-   Card8 relhiSwidth[4]-   Card8 relhiSheight[4]-   Card8 relhiCwidth[4]-   Card8 relhiCheight[4]-   Card8 relfhNWwidth[4]-   Card8 relfhNWheight[4]-   Card8 relfhSWwidth[4]-   Card8 relfhSWheight[4]-   Card8 relfhNEwidth[d]-   Card8 relfhNEheight[4]-   Card8 relfhSEwidth[4]-   Card8 relfhSEheight[4]-   Card8 relfhNwidth[4]-   Card8 relfhNheight[4]-   Card8 relfhWwidth[4]-   Card8 relfhWheight[4]-   Card8 relfhEwidth[4]-   Card8 relfhEheight[4]-   Card8 relfhSwidth[4]-   Card8 relfhSheight[4]-   Card8 relfhCwidth[4]-   Card8 relfhCheight[4]-   Card8 butnoNWwidth[4]-   Card8 butnoNWheight[4]-   Card8 butnoSWwidth[4]-   Card8 butnoSWheight[4]-   Card8 butnoNEwidth[4]-   Card8 butnoNEheight[4]-   Card8 butnoSEwidth[4]-   Card8 butnoSEheight[4]-   Card8 butnoNwidth[4]-   Card8 butnoNheight[4]-   Card8 butnoWwidth[4]-   Card8 butnoWheight[4]-   Card8 butnoEwidth[4]-   Card8 butnoEheight[4]-   Card8 butnoSwidth[4]-   Card8 butnoSheight[4]-   Card8 butnoCwidth[4]-   Card8 butnoCheight[4]-   Card8 butfoNWwidth[4]-   Card8 butfoNWheight[4]-   Card8 butfoSWwidth[4]-   Card8 butfoSWheight[4]-   Card8 butfoNEwidth[4]-   Card8 butfoNEheight[4]-   Card8 butfoSEwidth[4]-   Card8 butfoSEheight[4]-   Card8 butfoNwidth[4]-   Card8 butfoNheight[4]-   Card8 butfoWwidth[4]-   Card8 butfoWheight[4]-   Card8 butfoEwidth[4]-   Card8 butfoEheight[4]-   Card8 butfoSwidth[4]-   Card8 butfoSheight[4]-   Card8 butfoCwidth[4]-   Card8 butfoCheight[4]-   Card8 buthiNWwidth[4]-   Card8 buthiNWheight[4]-   Card8 buthiSWwidth[4]-   Card8 buthiSWheight[4]-   Card8 buthiNEwidth[4]-   Card8 buthiNEheight[4]-   Card8 buthiSEwidth[4]-   Card8 buthiSEheight[4]-   Card8 buthiNwidth[4]-   Card8 buthiNheight[4]-   Card8 buthiWwidth[4]-   Card8 buthiWheight[4]-   Card8 buthiEwidth[4]-   Card8 buthiEheight[4]-   Card8 buthiSwidth[4]-   Card8 buthiSheight[4]-   Card8 buthiCwidth[4]-   Card8 buthiCheight[4]-   Card8 butfhNWwidth[4-   Card8 butfhNWheight[4]-   Card8 butfhSWwidth[4]-   Card8 burfhSWheight[4]-   Card8 butfhNEwidth[4]-   Card8 butfhNEheight[4]-   Card8 butfhSEwidth[4]-   Card8 butfhSEheight[4]-   Card8 butfhNwidth[4]-   Card8 butfhNheight[4]-   Card8 butfhWwidth[4]-   Card8 butfhwheight[4]-   Card8 butfhEwidth[4]-   Card8 butfhEheight[4]-   Card8 butfhSwidth[4]-   Card8 butfhSheight[4]-   Card8 butfhCwidth[4]-   Card8 butfhCheight[4]-   Card8 choicewidth[4]-   Card8 choiceheight[4]-   Card8 chcklnowidth[4]-   Card8 chckinoheight[4]-   Card8 chcklsewidth[4]-   Card8 chcklseheight[4]-   Card8 chcklfowidth[4]-   Card8 chcklfoheight[4]-   Card8 chcklfswidth[4]-   Card8 chcklfsheight[4]-   Card8 chck2nowidth[4]-   Card8 chck2noheight[4]-   Card8 chck2sewidth[4]-   Card8 chck2seheight[4]-   Card8 chck2fowidth[4]-   Card8 chck2foheight[4]-   Card8 chck2fswidth[4]-   Card8 chck2faheight[4]-   Card8 slidNeVrwidth[4]-   Card8 slidNeVrheight[4]-   Card8 slidEVrwidth[4]-   Card8 slidEVrheight[4]-   Card8 slidSeVrwidth[4]-   Card8 slidSeVrheight[4]-   Card8 slidSwHrwidth[4]-   Card8 slidSwHrheight[4]-   Card8 slidSHrwidth[4]-   Card8 slidSHrheight[4]-   Card8 slidSeHrwidth[4]-   Card8 slidSeHrheight[4]-   Card8 slidSeVrHrwidth[4]-   Card8 slidSeVrHrheight[4]-   Card8 slidLiftNeVrwidth[4]-   Card8 slidLiftNeVrheight[4]-   Card8 slidLiftEVrwidth[4]-   Card8 slidLiftEVrheight[4]-   Card8 slidLiftSeVrwidth[4]-   Card8 slidLiftSeVrheight[4]-   Card8 slidLiftSwHrwidth[4]-   Card8 slidLiftSwHrheight[4]-   Card8 slidLiftSHrwidth[4]-   Card8 slidLiftSHrheight[4]-   Card8 slidLiftSeHrwidth[4]-   Card8 slidLiftSeHrheight[4]-   Card8 RelnoNWbuffer[width×height]-   Card8 RelnoSWbuffer[width×height]-   Card8 RelnoNEbuffer[width×height]-   Card8 RelnoSEbuffer[width×height]-   Card8 RelnoNbuffer[width×height]-   Card8 RelnoWbuffer[width×height]-   Card8 RelnoEbuffer[width×height]-   Card8 RelnoSbuffer[width×height]-   Card8 RelnoCbuffer[width×height]-   Card8 RelfoNWbuffer[width×height]-   Card8 RelfoSWbuffer[width×height]-   Card8 RelfoNEbuffer[width×height]-   Card8 ReltoSEbuffer[width×height]-   Card8 RelfoNbuffer[width×height]-   Card8 RelfoWbuffer[width×height]-   Card8 RelfoEbuffer[width×height]-   Card8 RelfoSbuffer[width×height]-   Card8 RelfoCbuffer[width×height]-   Card8 RelhiNWbuffer[width×height]-   Card8 RelhiSWbuffer[width×height]-   Card8 RelhiNEbuffer[width×height]-   Card8 RelhiSEbuffer[width×height]-   Card8 RelhiNbuffer[width×height]-   Card8 RelhiWbuffer[width×height]-   Card8 RelhiEbuffer[width×height]-   Card8 RelhiSbuffer[width×height]-   Card8 RelhiCbuffer[width×height]-   Card8 RelfhNWbuffer[width×height]-   Card8 RelfhSWbuffer[width×height]-   Card8 RelfhNEbuffer[width×height]-   Card8 RelfhSEbuffer[width×height]-   Card8 RelfhNbuffer[width×height]-   Card8 RelfhWbuffer[width×height]-   Card8 RelfhEbuffer[width×height]-   Card8 RelfhSbuffer[width×height]-   Card8 RelfhCbuffer[width×height]-   Card8 ButnoNWbuffer[width×height]-   Card8 ButnoSWbuffer[width×height]-   Card8 ButnoNEbuffer[width×height]-   Card8 ButnoSEbuffer[width×height]-   Card8 ButnoNbuffer[width×height]-   Card8 ButnoWbuffer[width×height]-   Card8 ButnoEbuffer[width×height]-   Card8 ButnoSbuffer[width×height]-   Card8 ButnoCbuffer[width×height]-   Card8 ButfoNWbuffer[width×height]-   Card8 ButfoSWbuffer[width×height]-   Card8 ButfoNEbuffer[width×height]-   Card8 ButfoSEbuffer[width×height]-   Card8 ButfoNbuffer[width×height]-   Card8 ButfoWbuffer[width×height]-   Card8 ButfoEbuffer[width×height]-   Card8 ButfoSbuffer[width×height]-   Card8 ButfoCbuffer[width×height]-   Card8 ButhiNWbuffer[width×height]-   Card8 ButhiSWbuffer[width×height]-   Card8 ButhiNEbuffer[width×height]-   Card8 ButhiSEbuffer[width×height]-   Card8 ButhiNbuffer[width×height]-   Card8 ButhiWbuffer[width×height]-   Card8 ButhiEbuffer[width×height]-   Card8 ButhiSbuffer[width×height]-   Card8 ButhiCbuffer[width×height]-   Card8 ButfhNWbuffer[width×height]-   Card8 ButfhSWbuffer[width×height]-   Card8 ButfhNEbuffer[width×height]-   Card8 ButfhSEbuffer[width×height]-   Card8 ButfhNbuffer[width×height]-   Card8 ButfhWbuffer[width×height]-   Card8 ButfhEbuffer[width×height]-   Card8 ButfhSbuffer[width×height]-   Card8 ButfhCbuffer[width×height]-   Card8 Choicebuffer[width×height]-   Card8 chcklnobuffer[width×height]-   Card8 chcklsebuffer[width×height]-   Card8 chcklfobuffer[width×height]-   Card8 chcklfsbuffer[width×height]-   Card8 chck2nobuffer[width×height]-   Card8 chck2sebuffer[width×height]-   Card8 chck2fobuffer[width×height]-   Card8 chck2fsbuffer[width×height]-   Card8 slidNeVrbuffer[width×height]-   Card8 slidEVrbuffer[width×height]-   Card8 slidSeVrbuffer[width×height]-   Card8 slidSwHrbuffer[width×height]-   Card8 slidSHrbuffer[width×height]-   Card8 slidSeHrbuffer[width×height]-   Card8 slidSeVrHrbuffer[width×height]-   Card8 slidLiftNeVrbuffer[width×height]-   Card8 slidLiftEVrbuffer[width×height]-   Card8 slidLiftSeVrbuffer[width×height]-   Card8 slidLiftSwHrbuffer[width×height]-   Card8 slidLiEtSHrbuffer[width×height]-   Card8 slidLiftSeHrbuffer[width×height]

For Example:

Width Height Width Height 0000000 8 8 8 8 0000020 8 8 8 8 0000040 8 8 88 0000060 8 8 8 8 0000100 8 8 8 8 0000120 8 8 8 8 0000140 8 8 8 80000160 8 8 8 8 0000200 8 8 1 1 0000220 8 8 8 8 0000240 8 8 8 8 00002608 8 8 8 0000300 8 8 8 8 0000320 1 1 8 8 0000340 8 8 8 8 0000360 8 8 8 80000400 8 8 8 8 0000420 8 8 1 1 0000440 8 8 8 8 0000460 8 8 8 8 00005008 8 8 8 0000520 8 8 8 8 0000540 1 1 8 8 0000560 8 8 8 8 0000600 8 8 8 80000620 8 8 8 8 0000640 8 8 1 1 0000660 8 8 8 8 0000700 8 8 8 8 00007208 8 8 8 0000740 8 8 8 8 0000760 1 1 8 8 0001000 8 8 8 8 0001020 8 8 8 80001040 8 8 8 8 0001060 8 8 1 1 0001100 1 6 1 6 1 6 1 6 0001120 1 6 1 61 6 1 6 0001140 1 6 1 6 1 6 1 6 0001160 1 6 1 6 1 6 1 6 0001200 1 6 1 68 8 0001220 8 8 8 8 0001240 8 8 8 8 0001260 8 8 1 1 0001300 2 2 2 20001320 2 2 2 2 0001340 2 2 2 2

Start of buffer 1 data. (relnoNW) (8 × 8 bytes) 0001360 \0 \0 \0 \0 \0266 004 004 \0 \0 \0 266 \n \r \r \r 0001400 \0 \0 \n \r 017 \r \v 001\0 266 \r 017 \r 001 001 001 0001420 \0 \n 017 \r 001 001 001 001 265 \r\r 001 001 001 001 001 0001440 004 \r \v 001 001 001 001 001 004 \v 001001 001 001 001 006 Start of buffer 2 data. (relnoSW) (8 × 8 bytes)0001460 004 004 263 \0 \0 \0 \0 \0 \r \r \v 004 \a \0 \0 \0 0001500 001001 001 270 004 262 \0 \0 001 001 001 001 \n 004 004 \0 0001520 001 001001 001 001 \n \a \0 001 001 001 001 001 270 \L 265 0001540 001 001 001001 001 270 \t \a 006 001 001 001 001 270 \C 006 Start of buffer 3 data.(relnoNE) (8 × 8 bytes) 0001560 004 \v 001 001 001 001 001 006 \b 001001 001 001 001 001 001 0001600 006 \n 001 001 001 001 001 001 \0 265 \n001 001 001 001 001 0001620 \0 006 \t \rL 001 001 001 001 \0 \0 261 \t\n \n \n \n 0001640 \0 \0 \0 006 022 265 265 \t \0 \0 \0 \0 \0 \a 006006 Start of buffer 4 data. (relnoSE) (8 × 8 bytes) 0001660 \r 001 001001 001 270 \t 006 001 001 001 001 001 270 \t 006 0001700 001 001 001001 001 \n 265 261 001 001 001 001 \n 266 261 \0 0001720 001 001 001 \n266 \b 261 \0 270 270 004 266 \b 261 \0 \0 0001740 \t \t \b 261 261 \0\0 \0 006 006 261 \0 \0 \0 \0 \0etc.reDrawAll

public void reDrawAll( )

Finds the widget with the focus, then the parents until no more. Topwindow then set to invisible and visible again. Then the whole windowshould be redrawn.

The various methods described above for displaying one or more graphicalobjects, for navigating between a plurality of such objects, or forreceiving input from the user may equally be applied to other areasprimarily, but not exclusively, within the context of the reception ofbroadcasts from a broadcast supplier. In general, any functionality of aset-top box involving visual interaction with a user may employ suchmethods.

For example, a navigable chain of icons, possibly with subchainsattached, could be employed in a home shopping application, to allow theuser to display articles, view prices, place orders and otherwiseinteract with the application. The graphical object used to place anorder might, when highlighted, automatically ‘flip’ in the mannerdescribed above between the symbol to buy (for example, a dollar sign,$) and text representing the amount spent so far, or the word “buy” inthe language of the subscriber. Alternatively, or in addition, agraphical object containing the word ‘buy’ in the subscriber's language,could appear whenever the ‘buy’ icon is selected, and provide a branchfor any sub-chains to ‘hang off’.

The ‘buy’ icon in the above example might be placed next to an iconwhich, when clicked, views the list of purchases made so far, andanother icon which, when clicked, sets delivery options for the productsjust bought, so as to provide a logical sequence of icons in the chainwhich the user can navigate. When the ‘buy’ icon is selected, asub-chain could appear with various subsidiary options, which mightinclude different credit plans in the case of more expensive items. Anytext information required from the user, such as a street address fordelivery, could be entered with the virtual keyboard.

In an electronic programme guide, similar methods could be employed, forinteractively browsing and displaying different channels, themes andtimes and dates. Further customisation might be possible forre-arranging the graphic options in the chain according to the user'spreferences; in the case of a chain of channels, the user's preferredchannels could be grouped at the head of the chain. Such a preferencecould be indicated by the user, or deduced by the programme.

Other applications for the methods described above include on-linecatalogues, news and weather services on demand, games, and generaladministration of the set-top box (managing its configuration, etc.). Inthe case of games, the head/tail flip-flop effect could be used toprovide in-game animations without necessarily requiring additionalmethods to be written, and the virtual keyboard could be used as analternative form of controller for more advanced types of game.

It should also be appreciated that all methods of interaction using aremote control, as described herein, may be substituted or supplementedby the use of a mouse (or other directional controller, such as arollerball or joystick) and/or keyboard (or other device having aplurality of keys), either by simulating the buttons of a remote control(for example using the numbers 0–9; the arrow keys, and the return keyon a keyboard) or directly (for example using the mouse to click onbuttons, and the keyboard to enter text directly instead of using thevirtual keyboard).

The Virtual Keyboard described above may be implemented on any devicehaving a plurality of keys, such as a games machine or a mobiletelephone, for example. In the latter case, the virtual keyboard couldbe displayed substantially as described on the screen of the telephone(on phones with a sufficiently large display), or in a compressed form(on phone with smaller displays). Such compression of the virtualkeyboard might entail showing only one number block of characters at atime, preferably with a suggestion of the characters or types ofcharacters which might be accessed by pressing the left, right, upand/or down keys (or their equivalents, for example in the case ofroller-type directional controllers). The compressed virtual keyboardmay be used in other applications, particularly where there is littlespace available to display the keyboard.

The term ‘check box’ may refer to a graphical object of any shape, forexample circular, which is able to display different states, preferablytwo states corresponding to ‘checked’ and ‘unchecked’, but possibly morethan two states, and which may alter its state in a consistent fashionwhen clicked or selected by the user. The ‘checked’ state may beindicated by a tick, cross or other embellishment on the box.

For ease of reference, the terms below used herein have the followingpreferred meanings:—

HTML: HyperText Markup Language, a language describing the documentswhich are interchanged on the Internet. The document may includereferences to sites, formatting information, sound and pictures, etc.

HTTP: HyperText Transport Protocol, a protocol for communicating betweenInternet servers holding HTML documents and a navigation application,which displays the HTML documents.

MPEG-2: Motion Picture Expert Group, a method of coding animated imagesand sound in realtime.

PPP: Point-to-Point Protocol, a distance access communications protocolallowing two computers to be networked via a modem.

PROXY SERVER: An application located on the server which allows secureInternet connections, and which also buffers HTTP and FTP requests.

SESSION: An instance of a type of connection or of an application inmemory at a given point in time.

URL: Uniform Resource Locator, an address used to locate a file orresources on the Internet. A link to a site designates the address ofthe resource contained in the web page.

WWW: World Wide Web, Internet network using local or remote documents. Aweb document is a web page, and the links in the page allow navigationbetween different pages and between different subjects, regardless ofwhether situated on a local or remote network.

GUI: Graphical User Interface.

WGT: Widget Toolkit.

It will be understood that the present invention has been describedabove purely by way of example, and modifications of detail can be madewithin the scope of the invention.

Each feature disclosed in the description, and (where appropriate) theclaims and drawings may be provided independently or in any appropriatecombination.

In any or all of the aforementioned, certain features of the presentinvention have been implemented using computer software. However, itwill of course be clear to the skilled man that any of these featuresmay be implemented using hardware or a combination of hardware andsoftware. Furthermore, it will be readily understood that the functionsperformed by the hardware, the computer software, and such like areperformed on or using electrical and like signals.

Features which relate to the storage of information may be implementedby suitable memory locations or stores. Features which relate to theprocessing of information may be implemented by a suitable processor orcontrol means, either in software or in hardware or in a combination ofthe two.

In any or all of the aforementioned, the invention may be embodied inany, some or all of the following forms: it may be embodied in a methodof operating a computer system; it may be embodied in the computersystem itself; it may be embodied in a computer system when programmedwith or adapted or arranged to execute the method of operating thatsystem; and/or it may be embodied in a computer-readable storage mediumhaving a program recorded thereon which is adapted to operate accordingto the method of operating the system.

As used herein throughout the term “computer system” may be interchangedfor “computer”, “system”, “equipment”, “apparatus”, “machine” and liketerms.

Reference numerals appearing in the claims are by way of illustrationonly and shall have no limiting effect on the scope of the claims.

The Applicant hereby declares, for the avoidance of doubt that he claimscopyright in the attached drawings.

1. A method of controlling the appearance of an object-oriented widgetin a graphical user interface, comprising: defining a look object class,wherein the look object class is linked into an application; andassociating the look object class with the object-oriented widget;wherein the look object class includes code or parameters determininghow the object-oriented widget is displayed, wherein the look objectclass is configured to control the appearance of the object-orientedwidget, and wherein the look object class includes an update counterwhose value is updated when the look object class is re-defined ormodified.
 2. A method according to claim 1, wherein the look objectclass is defined by object-oriented program code.
 3. A method accordingto claim 1, wherein the object-oriented widget includes an attributeidentifying the look object class associated with the object-orientedwidget.
 4. A method according to claim 1, further comprising modifyingthe appearance of the object-oriented widget by re-defining or modifyingthe look object class or by associating a different look object classwith the object-oriented widget.
 5. A method according to claim 1,wherein the look object class includes a validation mask which indicatesmethods that can be called by the look object class.
 6. A methodaccording to claim 1, further comprising controlling the appearance of aplurality of object-oriented widgets in a graphical user interface byassociating the look object class with the plurality of object-orientedwidgets.
 7. A method according to claim 6, wherein the plurality ofobject-oriented widgets comprises a linked chain.
 8. A method accordingto claim 1, wherein the look object class includes a counter whichindicates the number of object-oriented widgets which are associatedwith that look object class.
 9. Apparatus for controlling the appearanceof an object-oriented widget in a graphical user interface, comprising:means for defining a look object class, wherein the look object class islinked into an application; and means for associating the look objectclass with the object-oriented widget; and means for displaying theobject-oriented widget, wherein the object-oriented widget is anapplication intended to be displayed, wherein the look object class isconfigured to control the appearance of the object-oriented widget, andwherein the look object class includes an update counter whose value isupdated when the look object class is re-defined or modified.
 10. Acomputer program comprising code for: defining a look object class,wherein the look object class is linked into an application; andassociating the look object class with an object-oriented widget;wherein the object-oriented widget is an application intended to bedisplayed, and wherein the look object class is configured to controlthe appearance of the object-oriented widget, and wherein the lookobject class includes an update counter whose value is updated when thelook object class is re-defined or modified.
 11. A computer programproduct comprising a memory and processor, the memory having storedtherein an application, and the processor (under the control of theapplication) being adapted to carry out the method as claimed inclaim
 1. 12. A computer program product comprising a program forcarrying out the method as claimed in claim
 1. 13. A computer programfor carrying out the method of claim
 1. 14. A computer readable mediumhaving stored thereon a program for carrying out the method as claimedin claim 1.